1 // ignore-tidy-filelength
7 Within the check phase of type check, we check each item one at a time
8 (bodies of function expressions are checked as part of the containing
9 function). Inference is used to supply types wherever they are unknown.
11 By far the most complex case is checking the body of a function. This
12 can be broken down into several distinct phases:
14 - gather: creates type variables to represent the type of each local
15 variable and pattern binding.
17 - main: the main pass does the lion's share of the work: it
18 determines the types of all expressions, resolves
19 methods, checks for most invalid conditions, and so forth. In
20 some cases, where a type is unknown, it may create a type or region
21 variable and use that as the type of an expression.
23 In the process of checking, various constraints will be placed on
24 these type variables through the subtyping relationships requested
25 through the `demand` module. The `infer` module is in charge
26 of resolving those constraints.
28 - regionck: after main is complete, the regionck pass goes over all
29 types looking for regions and making sure that they did not escape
30 into places they are not in scope. This may also influence the
31 final assignments of the various region variables if there is some
34 - vtable: find and records the impls to use for each trait bound that
35 appears on a type parameter.
37 - writeback: writes the final types within a function body, replacing
38 type variables with their final inferred types. These final types
39 are written into the `tcx.node_types` table, which should *never* contain
40 any reference to a type variable.
44 While type checking a function, the intermediate types for the
45 expressions, blocks, and so forth contained within the function are
46 stored in `fcx.node_types` and `fcx.node_substs`. These types
47 may contain unresolved type variables. After type checking is
48 complete, the functions in the writeback module are used to take the
49 types from this table, resolve them, and then write them into their
50 permanent home in the type context `tcx`.
52 This means that during inferencing you should use `fcx.write_ty()`
53 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
54 nodes within the function.
56 The types of top-level items, which never contain unbound type
57 variables, are stored directly into the `tcx` tables.
59 N.B., a type variable is not the same thing as a type parameter. A
60 type variable is rather an "instance" of a type parameter: that is,
61 given a generic function `fn foo<T>(t: T)`: while checking the
62 function `foo`, the type `ty_param(0)` refers to the type `T`, which
63 is treated in abstract. When `foo()` is called, however, `T` will be
64 substituted for a fresh type variable `N`. This variable will
65 eventually be resolved to some concrete type (which might itself be
85 mod generator_interior;
89 use crate::astconv::{AstConv, PathSeg};
90 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
91 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
92 use rustc::hir::def::{CtorOf, Res, DefKind};
93 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
94 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
95 use rustc::hir::itemlikevisit::ItemLikeVisitor;
96 use rustc::hir::ptr::P;
97 use crate::middle::lang_items;
98 use crate::namespace::Namespace;
99 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
100 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
101 use rustc_data_structures::indexed_vec::Idx;
102 use rustc_target::spec::abi::Abi;
103 use rustc::infer::opaque_types::OpaqueTypeDecl;
104 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
105 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
106 use rustc::middle::region;
107 use rustc::mir::interpret::{ConstValue, GlobalId};
108 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
110 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
111 ToPolyTraitRef, ToPredicate, RegionKind, UserType
113 use rustc::ty::adjustment::{
114 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
116 use rustc::ty::fold::TypeFoldable;
117 use rustc::ty::query::Providers;
118 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
119 use rustc::ty::util::{Representability, IntTypeExt, Discr};
120 use rustc::ty::layout::VariantIdx;
121 use syntax_pos::{self, BytePos, Span, MultiSpan};
122 use syntax_pos::hygiene::CompilerDesugaringKind;
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
126 use syntax::source_map::{DUMMY_SP, original_sp};
127 use syntax::symbol::{kw, sym};
129 use std::cell::{Cell, RefCell, Ref, RefMut};
130 use std::collections::hash_map::Entry;
133 use std::mem::replace;
134 use std::ops::{self, Deref};
137 use crate::require_c_abi_if_c_variadic;
138 use crate::session::Session;
139 use crate::session::config::EntryFnType;
140 use crate::TypeAndSubsts;
142 use crate::util::captures::Captures;
143 use crate::util::common::{ErrorReported, indenter};
144 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
146 pub use self::Expectation::*;
147 use self::autoderef::Autoderef;
148 use self::callee::DeferredCallResolution;
149 use self::coercion::{CoerceMany, DynamicCoerceMany};
150 pub use self::compare_method::{compare_impl_method, compare_const_impl};
151 use self::method::{MethodCallee, SelfSource};
152 use self::TupleArgumentsFlag::*;
154 /// The type of a local binding, including the revealed type for anon types.
155 #[derive(Copy, Clone)]
156 pub struct LocalTy<'tcx> {
158 revealed_ty: Ty<'tcx>
161 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
162 #[derive(Copy, Clone)]
163 struct MaybeInProgressTables<'a, 'tcx> {
164 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
167 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
168 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
177 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
178 match self.maybe_tables {
179 Some(tables) => tables.borrow_mut(),
181 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
187 /// Closures defined within the function. For example:
190 /// bar(move|| { ... })
193 /// Here, the function `foo()` and the closure passed to
194 /// `bar()` will each have their own `FnCtxt`, but they will
195 /// share the inherited fields.
196 pub struct Inherited<'a, 'tcx> {
197 infcx: InferCtxt<'a, 'tcx>,
199 tables: MaybeInProgressTables<'a, 'tcx>,
201 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
203 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
205 // Some additional `Sized` obligations badly affect type inference.
206 // These obligations are added in a later stage of typeck.
207 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
209 // When we process a call like `c()` where `c` is a closure type,
210 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
211 // `FnOnce` closure. In that case, we defer full resolution of the
212 // call until upvar inference can kick in and make the
213 // decision. We keep these deferred resolutions grouped by the
214 // def-id of the closure, so that once we decide, we can easily go
215 // back and process them.
216 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
218 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
220 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
222 // Opaque types found in explicit return types and their
223 // associated fresh inference variable. Writeback resolves these
224 // variables to get the concrete type, which can be used to
225 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
226 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
228 /// Each type parameter has an implicit region bound that
229 /// indicates it must outlive at least the function body (the user
230 /// may specify stronger requirements). This field indicates the
231 /// region of the callee. If it is `None`, then the parameter
232 /// environment is for an item or something where the "callee" is
234 implicit_region_bound: Option<ty::Region<'tcx>>,
236 body_id: Option<hir::BodyId>,
239 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
240 type Target = InferCtxt<'a, 'tcx>;
241 fn deref(&self) -> &Self::Target {
246 /// When type-checking an expression, we propagate downward
247 /// whatever type hint we are able in the form of an `Expectation`.
248 #[derive(Copy, Clone, Debug)]
249 pub enum Expectation<'tcx> {
250 /// We know nothing about what type this expression should have.
253 /// This expression should have the type given (or some subtype).
254 ExpectHasType(Ty<'tcx>),
256 /// This expression will be cast to the `Ty`.
257 ExpectCastableToType(Ty<'tcx>),
259 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
260 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
261 ExpectRvalueLikeUnsized(Ty<'tcx>),
264 impl<'a, 'tcx> Expectation<'tcx> {
265 // Disregard "castable to" expectations because they
266 // can lead us astray. Consider for example `if cond
267 // {22} else {c} as u8` -- if we propagate the
268 // "castable to u8" constraint to 22, it will pick the
269 // type 22u8, which is overly constrained (c might not
270 // be a u8). In effect, the problem is that the
271 // "castable to" expectation is not the tightest thing
272 // we can say, so we want to drop it in this case.
273 // The tightest thing we can say is "must unify with
274 // else branch". Note that in the case of a "has type"
275 // constraint, this limitation does not hold.
277 // If the expected type is just a type variable, then don't use
278 // an expected type. Otherwise, we might write parts of the type
279 // when checking the 'then' block which are incompatible with the
281 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
283 ExpectHasType(ety) => {
284 let ety = fcx.shallow_resolve(ety);
285 if !ety.is_ty_var() {
291 ExpectRvalueLikeUnsized(ety) => {
292 ExpectRvalueLikeUnsized(ety)
298 /// Provides an expectation for an rvalue expression given an *optional*
299 /// hint, which is not required for type safety (the resulting type might
300 /// be checked higher up, as is the case with `&expr` and `box expr`), but
301 /// is useful in determining the concrete type.
303 /// The primary use case is where the expected type is a fat pointer,
304 /// like `&[isize]`. For example, consider the following statement:
306 /// let x: &[isize] = &[1, 2, 3];
308 /// In this case, the expected type for the `&[1, 2, 3]` expression is
309 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
310 /// expectation `ExpectHasType([isize])`, that would be too strong --
311 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
312 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
313 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
314 /// which still is useful, because it informs integer literals and the like.
315 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
316 /// for examples of where this comes up,.
317 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
318 match fcx.tcx.struct_tail(ty).sty {
319 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
320 ExpectRvalueLikeUnsized(ty)
322 _ => ExpectHasType(ty)
326 // Resolves `expected` by a single level if it is a variable. If
327 // there is no expected type or resolution is not possible (e.g.,
328 // no constraints yet present), just returns `None`.
329 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
331 NoExpectation => NoExpectation,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
344 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
345 match self.resolve(fcx) {
346 NoExpectation => None,
347 ExpectCastableToType(ty) |
349 ExpectRvalueLikeUnsized(ty) => Some(ty),
353 /// It sometimes happens that we want to turn an expectation into
354 /// a **hard constraint** (i.e., something that must be satisfied
355 /// for the program to type-check). `only_has_type` will return
356 /// such a constraint, if it exists.
357 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 ExpectHasType(ty) => Some(ty),
360 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
364 /// Like `only_has_type`, but instead of returning `None` if no
365 /// hard constraint exists, creates a fresh type variable.
366 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
367 self.only_has_type(fcx)
369 fcx.next_ty_var(TypeVariableOrigin {
370 kind: TypeVariableOriginKind::MiscVariable,
377 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
384 fn maybe_mut_place(m: hir::Mutability) -> Self {
386 hir::MutMutable => Needs::MutPlace,
387 hir::MutImmutable => Needs::None,
392 #[derive(Copy, Clone)]
393 pub struct UnsafetyState {
395 pub unsafety: hir::Unsafety,
396 pub unsafe_push_count: u32,
401 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
402 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
405 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
406 match self.unsafety {
407 // If this unsafe, then if the outer function was already marked as
408 // unsafe we shouldn't attribute the unsafe'ness to the block. This
409 // way the block can be warned about instead of ignoring this
410 // extraneous block (functions are never warned about).
411 hir::Unsafety::Unsafe if self.from_fn => *self,
414 let (unsafety, def, count) = match blk.rules {
415 hir::PushUnsafeBlock(..) =>
416 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
417 hir::PopUnsafeBlock(..) =>
418 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
419 hir::UnsafeBlock(..) =>
420 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
422 (unsafety, self.def, self.unsafe_push_count),
426 unsafe_push_count: count,
433 #[derive(Debug, Copy, Clone)]
439 /// Tracks whether executing a node may exit normally (versus
440 /// return/break/panic, which "diverge", leaving dead code in their
441 /// wake). Tracked semi-automatically (through type variables marked
442 /// as diverging), with some manual adjustments for control-flow
443 /// primitives (approximating a CFG).
444 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
446 /// Potentially unknown, some cases converge,
447 /// others require a CFG to determine them.
450 /// Definitely known to diverge and therefore
451 /// not reach the next sibling or its parent.
454 /// Same as `Always` but with a reachability
455 /// warning already emitted.
459 // Convenience impls for combinig `Diverges`.
461 impl ops::BitAnd for Diverges {
463 fn bitand(self, other: Self) -> Self {
464 cmp::min(self, other)
468 impl ops::BitOr for Diverges {
470 fn bitor(self, other: Self) -> Self {
471 cmp::max(self, other)
475 impl ops::BitAndAssign for Diverges {
476 fn bitand_assign(&mut self, other: Self) {
477 *self = *self & other;
481 impl ops::BitOrAssign for Diverges {
482 fn bitor_assign(&mut self, other: Self) {
483 *self = *self | other;
488 fn always(self) -> bool {
489 self >= Diverges::Always
493 pub struct BreakableCtxt<'tcx> {
496 // this is `null` for loops where break with a value is illegal,
497 // such as `while`, `for`, and `while let`
498 coerce: Option<DynamicCoerceMany<'tcx>>,
501 pub struct EnclosingBreakables<'tcx> {
502 stack: Vec<BreakableCtxt<'tcx>>,
503 by_id: HirIdMap<usize>,
506 impl<'tcx> EnclosingBreakables<'tcx> {
507 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
508 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
509 bug!("could not find enclosing breakable with id {}", target_id);
515 pub struct FnCtxt<'a, 'tcx> {
518 /// The parameter environment used for proving trait obligations
519 /// in this function. This can change when we descend into
520 /// closures (as they bring new things into scope), hence it is
521 /// not part of `Inherited` (as of the time of this writing,
522 /// closures do not yet change the environment, but they will
524 param_env: ty::ParamEnv<'tcx>,
526 /// Number of errors that had been reported when we started
527 /// checking this function. On exit, if we find that *more* errors
528 /// have been reported, we will skip regionck and other work that
529 /// expects the types within the function to be consistent.
530 // FIXME(matthewjasper) This should not exist, and it's not correct
531 // if type checking is run in parallel.
532 err_count_on_creation: usize,
534 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
535 ret_coercion_span: RefCell<Option<Span>>,
537 yield_ty: Option<Ty<'tcx>>,
539 ps: RefCell<UnsafetyState>,
541 /// Whether the last checked node generates a divergence (e.g.,
542 /// `return` will set this to `Always`). In general, when entering
543 /// an expression or other node in the tree, the initial value
544 /// indicates whether prior parts of the containing expression may
545 /// have diverged. It is then typically set to `Maybe` (and the
546 /// old value remembered) for processing the subparts of the
547 /// current expression. As each subpart is processed, they may set
548 /// the flag to `Always`, etc. Finally, at the end, we take the
549 /// result and "union" it with the original value, so that when we
550 /// return the flag indicates if any subpart of the parent
551 /// expression (up to and including this part) has diverged. So,
552 /// if you read it after evaluating a subexpression `X`, the value
553 /// you get indicates whether any subexpression that was
554 /// evaluating up to and including `X` diverged.
556 /// We currently use this flag only for diagnostic purposes:
558 /// - To warn about unreachable code: if, after processing a
559 /// sub-expression but before we have applied the effects of the
560 /// current node, we see that the flag is set to `Always`, we
561 /// can issue a warning. This corresponds to something like
562 /// `foo(return)`; we warn on the `foo()` expression. (We then
563 /// update the flag to `WarnedAlways` to suppress duplicate
564 /// reports.) Similarly, if we traverse to a fresh statement (or
565 /// tail expression) from a `Always` setting, we will issue a
566 /// warning. This corresponds to something like `{return;
567 /// foo();}` or `{return; 22}`, where we would warn on the
570 /// An expression represents dead code if, after checking it,
571 /// the diverges flag is set to something other than `Maybe`.
572 diverges: Cell<Diverges>,
574 /// Whether any child nodes have any type errors.
575 has_errors: Cell<bool>,
577 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
579 inh: &'a Inherited<'a, 'tcx>,
582 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
583 type Target = Inherited<'a, 'tcx>;
584 fn deref(&self) -> &Self::Target {
589 /// Helper type of a temporary returned by `Inherited::build(...)`.
590 /// Necessary because we can't write the following bound:
591 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
592 pub struct InheritedBuilder<'tcx> {
593 infcx: infer::InferCtxtBuilder<'tcx>,
597 impl Inherited<'_, 'tcx> {
598 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
599 let hir_id_root = if def_id.is_local() {
600 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
601 DefId::local(hir_id.owner)
607 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
613 impl<'tcx> InheritedBuilder<'tcx> {
614 fn enter<F, R>(&mut self, f: F) -> R
616 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
618 let def_id = self.def_id;
619 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
623 impl Inherited<'a, 'tcx> {
624 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
626 let item_id = tcx.hir().as_local_hir_id(def_id);
627 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
628 let implicit_region_bound = body_id.map(|body_id| {
629 let body = tcx.hir().body(body_id);
630 tcx.mk_region(ty::ReScope(region::Scope {
631 id: body.value.hir_id.local_id,
632 data: region::ScopeData::CallSite
637 tables: MaybeInProgressTables {
638 maybe_tables: infcx.in_progress_tables,
641 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
642 locals: RefCell::new(Default::default()),
643 deferred_sized_obligations: RefCell::new(Vec::new()),
644 deferred_call_resolutions: RefCell::new(Default::default()),
645 deferred_cast_checks: RefCell::new(Vec::new()),
646 deferred_generator_interiors: RefCell::new(Vec::new()),
647 opaque_types: RefCell::new(Default::default()),
648 implicit_region_bound,
653 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
654 debug!("register_predicate({:?})", obligation);
655 if obligation.has_escaping_bound_vars() {
656 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
661 .register_predicate_obligation(self, obligation);
664 fn register_predicates<I>(&self, obligations: I)
665 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
667 for obligation in obligations {
668 self.register_predicate(obligation);
672 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
673 self.register_predicates(infer_ok.obligations);
677 fn normalize_associated_types_in<T>(&self,
680 param_env: ty::ParamEnv<'tcx>,
682 where T : TypeFoldable<'tcx>
684 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
685 self.register_infer_ok_obligations(ok)
689 struct CheckItemTypesVisitor<'tcx> {
693 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
694 fn visit_item(&mut self, i: &'tcx hir::Item) {
695 check_item_type(self.tcx, i);
697 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
698 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
701 pub fn check_wf_new(tcx: TyCtxt<'_>) {
702 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
703 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
706 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
707 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
710 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
711 debug_assert!(crate_num == LOCAL_CRATE);
712 tcx.par_body_owners(|body_owner_def_id| {
713 tcx.ensure().typeck_tables_of(body_owner_def_id);
717 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
726 wfcheck::check_impl_item(tcx, def_id);
729 pub fn provide(providers: &mut Providers<'_>) {
730 method::provide(providers);
731 *providers = Providers {
737 check_item_well_formed,
738 check_trait_item_well_formed,
739 check_impl_item_well_formed,
740 check_mod_item_types,
745 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
746 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
749 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
750 /// with information about it's body-id and fn-decl (if any). Otherwise,
753 /// If this function returns "some", then `typeck_tables(def_id)` will
754 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
755 /// may not succeed. In some cases where this function returns `None`
756 /// (notably closures), `typeck_tables(def_id)` would wind up
757 /// redirecting to the owning function.
761 ) -> Option<(hir::BodyId, Option<&hir::FnDecl>)> {
762 match tcx.hir().get(id) {
763 Node::Item(item) => {
765 hir::ItemKind::Const(_, body) |
766 hir::ItemKind::Static(_, _, body) =>
768 hir::ItemKind::Fn(ref decl, .., body) =>
769 Some((body, Some(decl))),
774 Node::TraitItem(item) => {
776 hir::TraitItemKind::Const(_, Some(body)) =>
778 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
779 Some((body, Some(&sig.decl))),
784 Node::ImplItem(item) => {
786 hir::ImplItemKind::Const(_, body) =>
788 hir::ImplItemKind::Method(ref sig, body) =>
789 Some((body, Some(&sig.decl))),
794 Node::AnonConst(constant) => Some((constant.body, None)),
799 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
800 // Closures' tables come from their outermost function,
801 // as they are part of the same "inference environment".
802 let outer_def_id = tcx.closure_base_def_id(def_id);
803 if outer_def_id != def_id {
804 return tcx.has_typeck_tables(outer_def_id);
807 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
808 primary_body_of(tcx, id).is_some()
811 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
812 &*tcx.typeck_tables_of(def_id).used_trait_imports
815 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.typeck_tables_of(outer_def_id);
823 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
824 let span = tcx.hir().span(id);
826 // Figure out what primary body this item has.
827 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
828 span_bug!(span, "can't type-check body of {:?}", def_id);
830 let body = tcx.hir().body(body_id);
832 let tables = Inherited::build(tcx, def_id).enter(|inh| {
833 let param_env = tcx.param_env(def_id);
834 let fcx = if let Some(decl) = fn_decl {
835 let fn_sig = tcx.fn_sig(def_id);
837 check_abi(tcx, span, fn_sig.abi());
839 // Compute the fty from point of view of inside the fn.
841 tcx.liberate_late_bound_regions(def_id, &fn_sig);
843 inh.normalize_associated_types_in(body.value.span,
848 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
851 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
852 let expected_type = tcx.type_of(def_id);
853 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
854 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
856 let revealed_ty = if tcx.features().impl_trait_in_bindings {
857 fcx.instantiate_opaque_types_from_value(
866 // Gather locals in statics (because of block expressions).
867 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
871 fcx.write_ty(id, revealed_ty);
876 // All type checking constraints were added, try to fallback unsolved variables.
877 fcx.select_obligations_where_possible(false);
878 let mut fallback_has_occurred = false;
879 for ty in &fcx.unsolved_variables() {
880 fallback_has_occurred |= fcx.fallback_if_possible(ty);
882 fcx.select_obligations_where_possible(fallback_has_occurred);
884 // Even though coercion casts provide type hints, we check casts after fallback for
885 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
888 // Closure and generator analysis may run after fallback
889 // because they don't constrain other type variables.
890 fcx.closure_analyze(body);
891 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
892 fcx.resolve_generator_interiors(def_id);
894 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
895 let ty = fcx.normalize_ty(span, ty);
896 fcx.require_type_is_sized(ty, span, code);
898 fcx.select_all_obligations_or_error();
900 if fn_decl.is_some() {
901 fcx.regionck_fn(id, body);
903 fcx.regionck_expr(body);
906 fcx.resolve_type_vars_in_body(body)
909 // Consistency check our TypeckTables instance can hold all ItemLocalIds
910 // it will need to hold.
911 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
916 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
917 if !tcx.sess.target.target.is_abi_supported(abi) {
918 struct_span_err!(tcx.sess, span, E0570,
919 "The ABI `{}` is not supported for the current target", abi).emit()
923 struct GatherLocalsVisitor<'a, 'tcx> {
924 fcx: &'a FnCtxt<'a, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
929 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
934 kind: TypeVariableOriginKind::TypeInference,
937 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
944 // take type that the user specified
945 self.fcx.locals.borrow_mut().insert(nid, typ);
952 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
953 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
954 NestedVisitorMap::None
957 // Add explicitly-declared locals.
958 fn visit_local(&mut self, local: &'tcx hir::Local) {
959 let local_ty = match local.ty {
961 let o_ty = self.fcx.to_ty(&ty);
963 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
964 self.fcx.instantiate_opaque_types_from_value(
973 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
974 &UserType::Ty(revealed_ty)
976 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
977 ty.hir_id, o_ty, revealed_ty, c_ty);
978 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
980 Some(LocalTy { decl_ty: o_ty, revealed_ty })
984 self.assign(local.span, local.hir_id, local_ty);
986 debug!("local variable {:?} is assigned type {}",
988 self.fcx.ty_to_string(
989 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
990 intravisit::walk_local(self, local);
993 // Add pattern bindings.
994 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
995 if let PatKind::Binding(_, _, ident, _) = p.node {
996 let var_ty = self.assign(p.span, p.hir_id, None);
998 if !self.fcx.tcx.features().unsized_locals {
999 self.fcx.require_type_is_sized(var_ty, p.span,
1000 traits::VariableType(p.hir_id));
1003 debug!("pattern binding {} is assigned to {} with type {:?}",
1005 self.fcx.ty_to_string(
1006 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1009 intravisit::walk_pat(self, p);
1012 // Don't descend into the bodies of nested closures
1015 _: intravisit::FnKind<'tcx>,
1016 _: &'tcx hir::FnDecl,
1023 /// When `check_fn` is invoked on a generator (i.e., a body that
1024 /// includes yield), it returns back some information about the yield
1026 struct GeneratorTypes<'tcx> {
1027 /// Type of value that is yielded.
1030 /// Types that are captured (see `GeneratorInterior` for more).
1033 /// Indicates if the generator is movable or static (immovable).
1034 movability: hir::GeneratorMovability,
1037 /// Helper used for fns and closures. Does the grungy work of checking a function
1038 /// body and returns the function context used for that purpose, since in the case of a fn item
1039 /// there is still a bit more to do.
1042 /// * inherited: other fields inherited from the enclosing fn (if any)
1043 fn check_fn<'a, 'tcx>(
1044 inherited: &'a Inherited<'a, 'tcx>,
1045 param_env: ty::ParamEnv<'tcx>,
1046 fn_sig: ty::FnSig<'tcx>,
1047 decl: &'tcx hir::FnDecl,
1049 body: &'tcx hir::Body,
1050 can_be_generator: Option<hir::GeneratorMovability>,
1051 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1052 let mut fn_sig = fn_sig.clone();
1054 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1056 // Create the function context. This is either derived from scratch or,
1057 // in the case of closures, based on the outer context.
1058 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1059 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1061 let declared_ret_ty = fn_sig.output();
1062 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1063 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1068 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1069 fn_sig = fcx.tcx.mk_fn_sig(
1070 fn_sig.inputs().iter().cloned(),
1077 let span = body.value.span;
1079 if body.generator_kind.is_some() && can_be_generator.is_some() {
1080 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1081 kind: TypeVariableOriginKind::TypeInference,
1084 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1085 fcx.yield_ty = Some(yield_ty);
1088 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1089 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1090 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1092 // Add formal parameters.
1093 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1094 // Check the pattern.
1095 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1096 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1098 // Check that argument is Sized.
1099 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1100 // for simple cases like `fn foo(x: Trait)`,
1101 // where we would error once on the parameter as a whole, and once on the binding `x`.
1102 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1103 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1106 fcx.write_ty(arg.hir_id, arg_ty);
1109 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1111 fcx.check_return_expr(&body.value);
1113 // We insert the deferred_generator_interiors entry after visiting the body.
1114 // This ensures that all nested generators appear before the entry of this generator.
1115 // resolve_generator_interiors relies on this property.
1116 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1117 let interior = fcx.next_ty_var(TypeVariableOrigin {
1118 kind: TypeVariableOriginKind::MiscVariable,
1121 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1122 Some(GeneratorTypes {
1123 yield_ty: fcx.yield_ty.unwrap(),
1125 movability: can_be_generator.unwrap(),
1131 // Finalize the return check by taking the LUB of the return types
1132 // we saw and assigning it to the expected return type. This isn't
1133 // really expected to fail, since the coercions would have failed
1134 // earlier when trying to find a LUB.
1136 // However, the behavior around `!` is sort of complex. In the
1137 // event that the `actual_return_ty` comes back as `!`, that
1138 // indicates that the fn either does not return or "returns" only
1139 // values of type `!`. In this case, if there is an expected
1140 // return type that is *not* `!`, that should be ok. But if the
1141 // return type is being inferred, we want to "fallback" to `!`:
1143 // let x = move || panic!();
1145 // To allow for that, I am creating a type variable with diverging
1146 // fallback. This was deemed ever so slightly better than unifying
1147 // the return value with `!` because it allows for the caller to
1148 // make more assumptions about the return type (e.g., they could do
1150 // let y: Option<u32> = Some(x());
1152 // which would then cause this return type to become `u32`, not
1154 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1155 let mut actual_return_ty = coercion.complete(&fcx);
1156 if actual_return_ty.is_never() {
1157 actual_return_ty = fcx.next_diverging_ty_var(
1158 TypeVariableOrigin {
1159 kind: TypeVariableOriginKind::DivergingFn,
1164 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1166 // Check that the main return type implements the termination trait.
1167 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1168 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1169 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1170 if main_id == fn_id {
1171 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1172 let trait_ref = ty::TraitRef::new(term_id, substs);
1173 let return_ty_span = decl.output.span();
1174 let cause = traits::ObligationCause::new(
1175 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1177 inherited.register_predicate(
1178 traits::Obligation::new(
1179 cause, param_env, trait_ref.to_predicate()));
1184 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1185 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1186 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1187 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1188 // at this point we don't care if there are duplicate handlers or if the handler has
1189 // the wrong signature as this value we'll be used when writing metadata and that
1190 // only happens if compilation succeeded
1191 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1193 if declared_ret_ty.sty != ty::Never {
1194 fcx.tcx.sess.span_err(
1196 "return type should be `!`",
1200 let inputs = fn_sig.inputs();
1201 let span = fcx.tcx.hir().span(fn_id);
1202 if inputs.len() == 1 {
1203 let arg_is_panic_info = match inputs[0].sty {
1204 ty::Ref(region, ty, mutbl) => match ty.sty {
1205 ty::Adt(ref adt, _) => {
1206 adt.did == panic_info_did &&
1207 mutbl == hir::Mutability::MutImmutable &&
1208 *region != RegionKind::ReStatic
1215 if !arg_is_panic_info {
1216 fcx.tcx.sess.span_err(
1217 decl.inputs[0].span,
1218 "argument should be `&PanicInfo`",
1222 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1223 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1224 if !generics.params.is_empty() {
1225 fcx.tcx.sess.span_err(
1227 "should have no type parameters",
1233 let span = fcx.tcx.sess.source_map().def_span(span);
1234 fcx.tcx.sess.span_err(span, "function should have one argument");
1237 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1242 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1243 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1244 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1245 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1246 if declared_ret_ty.sty != ty::Never {
1247 fcx.tcx.sess.span_err(
1249 "return type should be `!`",
1253 let inputs = fn_sig.inputs();
1254 let span = fcx.tcx.hir().span(fn_id);
1255 if inputs.len() == 1 {
1256 let arg_is_alloc_layout = match inputs[0].sty {
1257 ty::Adt(ref adt, _) => {
1258 adt.did == alloc_layout_did
1263 if !arg_is_alloc_layout {
1264 fcx.tcx.sess.span_err(
1265 decl.inputs[0].span,
1266 "argument should be `Layout`",
1270 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1271 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1272 if !generics.params.is_empty() {
1273 fcx.tcx.sess.span_err(
1275 "`#[alloc_error_handler]` function should have no type \
1282 let span = fcx.tcx.sess.source_map().def_span(span);
1283 fcx.tcx.sess.span_err(span, "function should have one argument");
1286 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1294 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1295 let def_id = tcx.hir().local_def_id(id);
1296 let def = tcx.adt_def(def_id);
1297 def.destructor(tcx); // force the destructor to be evaluated
1298 check_representable(tcx, span, def_id);
1300 if def.repr.simd() {
1301 check_simd(tcx, span, def_id);
1304 check_transparent(tcx, span, def_id);
1305 check_packed(tcx, span, def_id);
1308 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1309 let def_id = tcx.hir().local_def_id(id);
1310 let def = tcx.adt_def(def_id);
1311 def.destructor(tcx); // force the destructor to be evaluated
1312 check_representable(tcx, span, def_id);
1313 check_transparent(tcx, span, def_id);
1314 check_packed(tcx, span, def_id);
1317 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1318 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1319 let mut err = struct_span_err!(
1320 tcx.sess, span, E0720,
1321 "opaque type expands to a recursive type",
1323 err.span_label(span, "expands to self-referential type");
1324 if let ty::Opaque(..) = partially_expanded_type.sty {
1325 err.note("type resolves to itself");
1327 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1333 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1335 "check_item_type(it.hir_id={}, it.name={})",
1337 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1339 let _indenter = indenter();
1341 // Consts can play a role in type-checking, so they are included here.
1342 hir::ItemKind::Static(..) => {
1343 let def_id = tcx.hir().local_def_id(it.hir_id);
1344 tcx.typeck_tables_of(def_id);
1345 maybe_check_static_with_link_section(tcx, def_id, it.span);
1347 hir::ItemKind::Const(..) => {
1348 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1350 hir::ItemKind::Enum(ref enum_definition, _) => {
1351 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1353 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1354 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1355 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1356 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1357 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1358 check_impl_items_against_trait(
1365 let trait_def_id = impl_trait_ref.def_id;
1366 check_on_unimplemented(tcx, trait_def_id, it);
1369 hir::ItemKind::Trait(..) => {
1370 let def_id = tcx.hir().local_def_id(it.hir_id);
1371 check_on_unimplemented(tcx, def_id, it);
1373 hir::ItemKind::Struct(..) => {
1374 check_struct(tcx, it.hir_id, it.span);
1376 hir::ItemKind::Union(..) => {
1377 check_union(tcx, it.hir_id, it.span);
1379 hir::ItemKind::Existential(..) => {
1380 let def_id = tcx.hir().local_def_id(it.hir_id);
1382 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1383 check_opaque(tcx, def_id, substs, it.span);
1385 hir::ItemKind::Ty(..) => {
1386 let def_id = tcx.hir().local_def_id(it.hir_id);
1387 let pty_ty = tcx.type_of(def_id);
1388 let generics = tcx.generics_of(def_id);
1389 check_bounds_are_used(tcx, &generics, pty_ty);
1391 hir::ItemKind::ForeignMod(ref m) => {
1392 check_abi(tcx, it.span, m.abi);
1394 if m.abi == Abi::RustIntrinsic {
1395 for item in &m.items {
1396 intrinsic::check_intrinsic_type(tcx, item);
1398 } else if m.abi == Abi::PlatformIntrinsic {
1399 for item in &m.items {
1400 intrinsic::check_platform_intrinsic_type(tcx, item);
1403 for item in &m.items {
1404 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1405 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1406 let mut err = struct_span_err!(
1410 "foreign items may not have type parameters"
1412 err.span_label(item.span, "can't have type parameters");
1413 // FIXME: once we start storing spans for type arguments, turn this into a
1416 "use specialization instead of type parameters by replacing them \
1417 with concrete types like `u32`",
1422 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1423 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1428 _ => { /* nothing to do */ }
1432 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1433 // Only restricted on wasm32 target for now
1434 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1438 // If `#[link_section]` is missing, then nothing to verify
1439 let attrs = tcx.codegen_fn_attrs(id);
1440 if attrs.link_section.is_none() {
1444 // For the wasm32 target statics with #[link_section] are placed into custom
1445 // sections of the final output file, but this isn't link custom sections of
1446 // other executable formats. Namely we can only embed a list of bytes,
1447 // nothing with pointers to anything else or relocations. If any relocation
1448 // show up, reject them here.
1449 let instance = ty::Instance::mono(tcx, id);
1450 let cid = GlobalId {
1454 let param_env = ty::ParamEnv::reveal_all();
1455 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1456 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1459 bug!("Matching on non-ByRef static")
1461 if alloc.relocations.len() != 0 {
1462 let msg = "statics with a custom `#[link_section]` must be a \
1463 simple list of bytes on the wasm target with no \
1464 extra levels of indirection such as references";
1465 tcx.sess.span_err(span, msg);
1470 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1471 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1472 // an error would be reported if this fails.
1473 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1476 fn report_forbidden_specialization(
1478 impl_item: &hir::ImplItem,
1481 let mut err = struct_span_err!(
1482 tcx.sess, impl_item.span, E0520,
1483 "`{}` specializes an item from a parent `impl`, but \
1484 that item is not marked `default`",
1486 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1489 match tcx.span_of_impl(parent_impl) {
1491 err.span_label(span, "parent `impl` is here");
1492 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1496 err.note(&format!("parent implementation is in crate `{}`", cname));
1503 fn check_specialization_validity<'tcx>(
1505 trait_def: &ty::TraitDef,
1506 trait_item: &ty::AssocItem,
1508 impl_item: &hir::ImplItem,
1510 let ancestors = trait_def.ancestors(tcx, impl_id);
1512 let kind = match impl_item.node {
1513 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1514 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1515 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1516 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1519 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1520 .map(|node_item| node_item.map(|parent| parent.defaultness));
1522 if let Some(parent) = parent {
1523 if tcx.impl_item_is_final(&parent) {
1524 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1530 fn check_impl_items_against_trait<'tcx>(
1534 impl_trait_ref: ty::TraitRef<'tcx>,
1535 impl_item_refs: &[hir::ImplItemRef],
1537 let impl_span = tcx.sess.source_map().def_span(impl_span);
1539 // If the trait reference itself is erroneous (so the compilation is going
1540 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1541 // isn't populated for such impls.
1542 if impl_trait_ref.references_error() { return; }
1544 // Locate trait definition and items
1545 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1546 let mut overridden_associated_type = None;
1548 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1550 // Check existing impl methods to see if they are both present in trait
1551 // and compatible with trait signature
1552 for impl_item in impl_items() {
1553 let ty_impl_item = tcx.associated_item(
1554 tcx.hir().local_def_id(impl_item.hir_id));
1555 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1556 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1557 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1559 // Not compatible, but needed for the error message
1560 tcx.associated_items(impl_trait_ref.def_id)
1561 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1564 // Check that impl definition matches trait definition
1565 if let Some(ty_trait_item) = ty_trait_item {
1566 match impl_item.node {
1567 hir::ImplItemKind::Const(..) => {
1568 // Find associated const definition.
1569 if ty_trait_item.kind == ty::AssocKind::Const {
1570 compare_const_impl(tcx,
1576 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1577 "item `{}` is an associated const, \
1578 which doesn't match its trait `{}`",
1581 err.span_label(impl_item.span, "does not match trait");
1582 // We can only get the spans from local trait definition
1583 // Same for E0324 and E0325
1584 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1585 err.span_label(trait_span, "item in trait");
1590 hir::ImplItemKind::Method(..) => {
1591 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1592 if ty_trait_item.kind == ty::AssocKind::Method {
1593 compare_impl_method(tcx,
1600 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1601 "item `{}` is an associated method, \
1602 which doesn't match its trait `{}`",
1605 err.span_label(impl_item.span, "does not match trait");
1606 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1607 err.span_label(trait_span, "item in trait");
1612 hir::ImplItemKind::Existential(..) |
1613 hir::ImplItemKind::Type(_) => {
1614 if ty_trait_item.kind == ty::AssocKind::Type {
1615 if ty_trait_item.defaultness.has_value() {
1616 overridden_associated_type = Some(impl_item);
1619 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1620 "item `{}` is an associated type, \
1621 which doesn't match its trait `{}`",
1624 err.span_label(impl_item.span, "does not match trait");
1625 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1626 err.span_label(trait_span, "item in trait");
1633 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1637 // Check for missing items from trait
1638 let mut missing_items = Vec::new();
1639 let mut invalidated_items = Vec::new();
1640 let associated_type_overridden = overridden_associated_type.is_some();
1641 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1642 let is_implemented = trait_def.ancestors(tcx, impl_id)
1643 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1645 .map(|node_item| !node_item.node.is_from_trait())
1648 if !is_implemented && !tcx.impl_is_default(impl_id) {
1649 if !trait_item.defaultness.has_value() {
1650 missing_items.push(trait_item);
1651 } else if associated_type_overridden {
1652 invalidated_items.push(trait_item.ident);
1657 if !missing_items.is_empty() {
1658 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1659 "not all trait items implemented, missing: `{}`",
1660 missing_items.iter()
1661 .map(|trait_item| trait_item.ident.to_string())
1662 .collect::<Vec<_>>().join("`, `"));
1663 err.span_label(impl_span, format!("missing `{}` in implementation",
1664 missing_items.iter()
1665 .map(|trait_item| trait_item.ident.to_string())
1666 .collect::<Vec<_>>().join("`, `")));
1667 for trait_item in missing_items {
1668 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1669 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1671 err.note_trait_signature(trait_item.ident.to_string(),
1672 trait_item.signature(tcx));
1678 if !invalidated_items.is_empty() {
1679 let invalidator = overridden_associated_type.unwrap();
1680 span_err!(tcx.sess, invalidator.span, E0399,
1681 "the following trait items need to be reimplemented \
1682 as `{}` was overridden: `{}`",
1684 invalidated_items.iter()
1685 .map(|name| name.to_string())
1686 .collect::<Vec<_>>().join("`, `"))
1690 /// Checks whether a type can be represented in memory. In particular, it
1691 /// identifies types that contain themselves without indirection through a
1692 /// pointer, which would mean their size is unbounded.
1693 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1694 let rty = tcx.type_of(item_def_id);
1696 // Check that it is possible to represent this type. This call identifies
1697 // (1) types that contain themselves and (2) types that contain a different
1698 // recursive type. It is only necessary to throw an error on those that
1699 // contain themselves. For case 2, there must be an inner type that will be
1700 // caught by case 1.
1701 match rty.is_representable(tcx, sp) {
1702 Representability::SelfRecursive(spans) => {
1703 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1705 err.span_label(span, "recursive without indirection");
1710 Representability::Representable | Representability::ContainsRecursive => (),
1715 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1716 let t = tcx.type_of(def_id);
1717 if let ty::Adt(def, substs) = t.sty {
1718 if def.is_struct() {
1719 let fields = &def.non_enum_variant().fields;
1720 if fields.is_empty() {
1721 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1724 let e = fields[0].ty(tcx, substs);
1725 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1726 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1727 .span_label(sp, "SIMD elements must have the same type")
1732 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1733 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1735 span_err!(tcx.sess, sp, E0077,
1736 "SIMD vector element type should be machine type");
1744 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1745 let repr = tcx.adt_def(def_id).repr;
1747 for attr in tcx.get_attrs(def_id).iter() {
1748 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1749 if let attr::ReprPacked(pack) = r {
1750 if pack != repr.pack {
1751 struct_span_err!(tcx.sess, sp, E0634,
1752 "type has conflicting packed representation hints").emit();
1758 struct_span_err!(tcx.sess, sp, E0587,
1759 "type has conflicting packed and align representation hints").emit();
1761 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1762 struct_span_err!(tcx.sess, sp, E0588,
1763 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1768 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1769 let t = tcx.type_of(def_id);
1770 if stack.contains(&def_id) {
1771 debug!("check_packed_inner: {:?} is recursive", t);
1774 if let ty::Adt(def, substs) = t.sty {
1775 if def.is_struct() || def.is_union() {
1776 if tcx.adt_def(def.did).repr.align > 0 {
1779 // push struct def_id before checking fields
1781 for field in &def.non_enum_variant().fields {
1782 let f = field.ty(tcx, substs);
1783 if let ty::Adt(def, _) = f.sty {
1784 if check_packed_inner(tcx, def.did, stack) {
1789 // only need to pop if not early out
1796 /// Emit an error when encountering more or less than one variant in a transparent enum.
1797 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1798 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1799 tcx.hir().span_if_local(variant.def_id).unwrap()
1802 "needs exactly one variant, but has {}",
1805 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1806 err.span_label(sp, &msg);
1807 if let &[ref start.., ref end] = &variant_spans[..] {
1808 for variant_span in start {
1809 err.span_label(*variant_span, "");
1811 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1816 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1818 fn bad_non_zero_sized_fields<'tcx>(
1820 adt: &'tcx ty::AdtDef,
1822 field_spans: impl Iterator<Item = Span>,
1825 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1826 let mut err = struct_span_err!(
1830 "{}transparent {} {}",
1831 if adt.is_enum() { "the variant of a " } else { "" },
1835 err.span_label(sp, &msg);
1836 for sp in field_spans {
1837 err.span_label(sp, "this field is non-zero-sized");
1842 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1843 let adt = tcx.adt_def(def_id);
1844 if !adt.repr.transparent() {
1847 let sp = tcx.sess.source_map().def_span(sp);
1850 if !tcx.features().transparent_enums {
1852 &tcx.sess.parse_sess,
1853 sym::transparent_enums,
1855 GateIssue::Language,
1856 "transparent enums are unstable",
1859 if adt.variants.len() != 1 {
1860 bad_variant_count(tcx, adt, sp, def_id);
1861 if adt.variants.is_empty() {
1862 // Don't bother checking the fields. No variants (and thus no fields) exist.
1868 if adt.is_union() && !tcx.features().transparent_unions {
1869 emit_feature_err(&tcx.sess.parse_sess,
1870 sym::transparent_unions,
1872 GateIssue::Language,
1873 "transparent unions are unstable");
1876 // For each field, figure out if it's known to be a ZST and align(1)
1877 let field_infos = adt.all_fields().map(|field| {
1878 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1879 let param_env = tcx.param_env(field.did);
1880 let layout = tcx.layout_of(param_env.and(ty));
1881 // We are currently checking the type this field came from, so it must be local
1882 let span = tcx.hir().span_if_local(field.did).unwrap();
1883 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1884 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1888 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1893 let non_zst_count = non_zst_fields.clone().count();
1894 if non_zst_count != 1 {
1895 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1897 for (span, zst, align1) in field_infos {
1903 "zero-sized field in transparent {} has alignment larger than 1",
1905 ).span_label(span, "has alignment larger than 1").emit();
1910 #[allow(trivial_numeric_casts)]
1911 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1912 let def_id = tcx.hir().local_def_id(id);
1913 let def = tcx.adt_def(def_id);
1914 def.destructor(tcx); // force the destructor to be evaluated
1917 let attributes = tcx.get_attrs(def_id);
1918 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1920 tcx.sess, attr.span, E0084,
1921 "unsupported representation for zero-variant enum")
1922 .span_label(sp, "zero-variant enum")
1927 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1928 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1929 if !tcx.features().repr128 {
1930 emit_feature_err(&tcx.sess.parse_sess,
1933 GateIssue::Language,
1934 "repr with 128-bit type is unstable");
1939 if let Some(ref e) = v.node.disr_expr {
1940 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
1944 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1946 |var: &hir::Variant| match var.node.data {
1947 hir::VariantData::Unit(..) => true,
1951 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1952 let has_non_units = vs.iter().any(|var| !is_unit(var));
1953 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1954 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1956 if disr_non_unit || (disr_units && has_non_units) {
1957 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1958 "`#[repr(inttype)]` must be specified");
1963 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1964 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1965 // Check for duplicate discriminant values
1966 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1967 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1968 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1969 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1970 let i_span = match variant_i.node.disr_expr {
1971 Some(ref expr) => tcx.hir().span(expr.hir_id),
1972 None => tcx.hir().span(variant_i_hir_id)
1974 let span = match v.node.disr_expr {
1975 Some(ref expr) => tcx.hir().span(expr.hir_id),
1978 struct_span_err!(tcx.sess, span, E0081,
1979 "discriminant value `{}` already exists", disr_vals[i])
1980 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1981 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1984 disr_vals.push(discr);
1987 check_representable(tcx, sp, def_id);
1988 check_transparent(tcx, sp, def_id);
1991 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
1992 span_err!(tcx.sess, span, E0533,
1993 "expected unit struct/variant or constant, found {} `{}`",
1995 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1998 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
1999 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2003 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2004 -> &'tcx ty::GenericPredicates<'tcx>
2007 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2008 let item_id = tcx.hir().ty_param_owner(hir_id);
2009 let item_def_id = tcx.hir().local_def_id(item_id);
2010 let generics = tcx.generics_of(item_def_id);
2011 let index = generics.param_def_id_to_index[&def_id];
2012 tcx.arena.alloc(ty::GenericPredicates {
2014 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2016 ty::Predicate::Trait(ref data)
2017 if data.skip_binder().self_ty().is_param(index) => {
2018 // HACK(eddyb) should get the original `Span`.
2019 let span = tcx.def_span(def_id);
2020 Some((predicate, span))
2030 def: Option<&ty::GenericParamDef>,
2032 ) -> Option<ty::Region<'tcx>> {
2034 Some(def) => infer::EarlyBoundRegion(span, def.name),
2035 None => infer::MiscVariable(span)
2037 Some(self.next_region_var(v))
2040 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2041 if let Some(param) = param {
2042 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2047 self.next_ty_var(TypeVariableOrigin {
2048 kind: TypeVariableOriginKind::TypeInference,
2057 param: Option<&ty::GenericParamDef>,
2059 ) -> &'tcx Const<'tcx> {
2060 if let Some(param) = param {
2061 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2066 self.next_const_var(ty, ConstVariableOrigin {
2067 kind: ConstVariableOriginKind::ConstInference,
2073 fn projected_ty_from_poly_trait_ref(&self,
2076 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2079 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2081 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2085 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2088 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2089 if ty.has_escaping_bound_vars() {
2090 ty // FIXME: normalization and escaping regions
2092 self.normalize_associated_types_in(span, &ty)
2096 fn set_tainted_by_errors(&self) {
2097 self.infcx.set_tainted_by_errors()
2100 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2101 self.write_ty(hir_id, ty)
2105 /// Controls whether the arguments are tupled. This is used for the call
2108 /// Tupling means that all call-side arguments are packed into a tuple and
2109 /// passed as a single parameter. For example, if tupling is enabled, this
2112 /// fn f(x: (isize, isize))
2114 /// Can be called as:
2121 #[derive(Clone, Eq, PartialEq)]
2122 enum TupleArgumentsFlag {
2127 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2129 inh: &'a Inherited<'a, 'tcx>,
2130 param_env: ty::ParamEnv<'tcx>,
2131 body_id: hir::HirId,
2132 ) -> FnCtxt<'a, 'tcx> {
2136 err_count_on_creation: inh.tcx.sess.err_count(),
2138 ret_coercion_span: RefCell::new(None),
2140 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2141 hir::CRATE_HIR_ID)),
2142 diverges: Cell::new(Diverges::Maybe),
2143 has_errors: Cell::new(false),
2144 enclosing_breakables: RefCell::new(EnclosingBreakables {
2146 by_id: Default::default(),
2152 pub fn sess(&self) -> &Session {
2156 pub fn errors_reported_since_creation(&self) -> bool {
2157 self.tcx.sess.err_count() > self.err_count_on_creation
2160 /// Produces warning on the given node, if the current point in the
2161 /// function is unreachable, and there hasn't been another warning.
2162 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2163 if self.diverges.get() == Diverges::Always &&
2164 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2165 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2166 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2167 !span.is_compiler_desugaring(CompilerDesugaringKind::CondTemporary) {
2168 self.diverges.set(Diverges::WarnedAlways);
2170 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2172 let msg = format!("unreachable {}", kind);
2173 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2179 code: ObligationCauseCode<'tcx>)
2180 -> ObligationCause<'tcx> {
2181 ObligationCause::new(span, self.body_id, code)
2184 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2185 self.cause(span, ObligationCauseCode::MiscObligation)
2188 /// Resolves type variables in `ty` if possible. Unlike the infcx
2189 /// version (resolve_vars_if_possible), this version will
2190 /// also select obligations if it seems useful, in an effort
2191 /// to get more type information.
2192 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2193 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2195 // No Infer()? Nothing needs doing.
2196 if !ty.has_infer_types() {
2197 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2201 // If `ty` is a type variable, see whether we already know what it is.
2202 ty = self.resolve_vars_if_possible(&ty);
2203 if !ty.has_infer_types() {
2204 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2208 // If not, try resolving pending obligations as much as
2209 // possible. This can help substantially when there are
2210 // indirect dependencies that don't seem worth tracking
2212 self.select_obligations_where_possible(false);
2213 ty = self.resolve_vars_if_possible(&ty);
2215 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2219 fn record_deferred_call_resolution(
2221 closure_def_id: DefId,
2222 r: DeferredCallResolution<'tcx>,
2224 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2225 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2228 fn remove_deferred_call_resolutions(
2230 closure_def_id: DefId,
2231 ) -> Vec<DeferredCallResolution<'tcx>> {
2232 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2233 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2236 pub fn tag(&self) -> String {
2237 format!("{:p}", self)
2240 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2241 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2242 span_bug!(span, "no type for local variable {}",
2243 self.tcx.hir().node_to_string(nid))
2248 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2249 debug!("write_ty({:?}, {:?}) in fcx {}",
2250 id, self.resolve_vars_if_possible(&ty), self.tag());
2251 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2253 if ty.references_error() {
2254 self.has_errors.set(true);
2255 self.set_tainted_by_errors();
2259 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2260 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2263 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2264 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2267 pub fn write_method_call(&self,
2269 method: MethodCallee<'tcx>) {
2270 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2271 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2272 self.write_substs(hir_id, method.substs);
2274 // When the method is confirmed, the `method.substs` includes
2275 // parameters from not just the method, but also the impl of
2276 // the method -- in particular, the `Self` type will be fully
2277 // resolved. However, those are not something that the "user
2278 // specified" -- i.e., those types come from the inferred type
2279 // of the receiver, not something the user wrote. So when we
2280 // create the user-substs, we want to replace those earlier
2281 // types with just the types that the user actually wrote --
2282 // that is, those that appear on the *method itself*.
2284 // As an example, if the user wrote something like
2285 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2286 // type of `foo` (possibly adjusted), but we don't want to
2287 // include that. We want just the `[_, u32]` part.
2288 if !method.substs.is_noop() {
2289 let method_generics = self.tcx.generics_of(method.def_id);
2290 if !method_generics.params.is_empty() {
2291 let user_type_annotation = self.infcx.probe(|_| {
2292 let user_substs = UserSubsts {
2293 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2294 let i = param.index as usize;
2295 if i < method_generics.parent_count {
2296 self.infcx.var_for_def(DUMMY_SP, param)
2301 user_self_ty: None, // not relevant here
2304 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2310 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2311 self.write_user_type_annotation(hir_id, user_type_annotation);
2316 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2317 if !substs.is_noop() {
2318 debug!("write_substs({:?}, {:?}) in fcx {}",
2323 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2327 /// Given the substs that we just converted from the HIR, try to
2328 /// canonicalize them and store them as user-given substitutions
2329 /// (i.e., substitutions that must be respected by the NLL check).
2331 /// This should be invoked **before any unifications have
2332 /// occurred**, so that annotations like `Vec<_>` are preserved
2334 pub fn write_user_type_annotation_from_substs(
2338 substs: SubstsRef<'tcx>,
2339 user_self_ty: Option<UserSelfTy<'tcx>>,
2342 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2343 user_self_ty={:?} in fcx {}",
2344 hir_id, def_id, substs, user_self_ty, self.tag(),
2347 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2348 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2349 &UserType::TypeOf(def_id, UserSubsts {
2354 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2355 self.write_user_type_annotation(hir_id, canonicalized);
2359 pub fn write_user_type_annotation(
2362 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2365 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2366 hir_id, canonical_user_type_annotation, self.tag(),
2369 if !canonical_user_type_annotation.is_identity() {
2370 self.tables.borrow_mut().user_provided_types_mut().insert(
2371 hir_id, canonical_user_type_annotation
2374 debug!("write_user_type_annotation: skipping identity substs");
2378 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2379 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2385 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2386 Entry::Vacant(entry) => { entry.insert(adj); },
2387 Entry::Occupied(mut entry) => {
2388 debug!(" - composing on top of {:?}", entry.get());
2389 match (&entry.get()[..], &adj[..]) {
2390 // Applying any adjustment on top of a NeverToAny
2391 // is a valid NeverToAny adjustment, because it can't
2393 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2395 Adjustment { kind: Adjust::Deref(_), .. },
2396 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2398 Adjustment { kind: Adjust::Deref(_), .. },
2399 .. // Any following adjustments are allowed.
2401 // A reborrow has no effect before a dereference.
2403 // FIXME: currently we never try to compose autoderefs
2404 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2406 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2407 expr, entry.get(), adj)
2409 *entry.get_mut() = adj;
2414 /// Basically whenever we are converting from a type scheme into
2415 /// the fn body space, we always want to normalize associated
2416 /// types as well. This function combines the two.
2417 fn instantiate_type_scheme<T>(&self,
2419 substs: SubstsRef<'tcx>,
2422 where T : TypeFoldable<'tcx>
2424 let value = value.subst(self.tcx, substs);
2425 let result = self.normalize_associated_types_in(span, &value);
2426 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2433 /// As `instantiate_type_scheme`, but for the bounds found in a
2434 /// generic type scheme.
2435 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2436 -> ty::InstantiatedPredicates<'tcx> {
2437 let bounds = self.tcx.predicates_of(def_id);
2438 let result = bounds.instantiate(self.tcx, substs);
2439 let result = self.normalize_associated_types_in(span, &result);
2440 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2447 /// Replaces the opaque types from the given value with type variables,
2448 /// and records the `OpaqueTypeMap` for later use during writeback. See
2449 /// `InferCtxt::instantiate_opaque_types` for more details.
2450 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2452 parent_id: hir::HirId,
2456 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2457 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2461 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2462 self.instantiate_opaque_types(
2471 let mut opaque_types = self.opaque_types.borrow_mut();
2472 for (ty, decl) in opaque_type_map {
2473 let old_value = opaque_types.insert(ty, decl);
2474 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2480 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2481 where T : TypeFoldable<'tcx>
2483 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2486 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2488 where T : TypeFoldable<'tcx>
2490 self.inh.partially_normalize_associated_types_in(span,
2496 pub fn require_type_meets(&self,
2499 code: traits::ObligationCauseCode<'tcx>,
2502 self.register_bound(
2505 traits::ObligationCause::new(span, self.body_id, code));
2508 pub fn require_type_is_sized(&self,
2511 code: traits::ObligationCauseCode<'tcx>)
2513 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2514 self.require_type_meets(ty, span, code, lang_item);
2517 pub fn require_type_is_sized_deferred(&self,
2520 code: traits::ObligationCauseCode<'tcx>)
2522 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2525 pub fn register_bound(&self,
2528 cause: traits::ObligationCause<'tcx>)
2530 self.fulfillment_cx.borrow_mut()
2531 .register_bound(self, self.param_env, ty, def_id, cause);
2534 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2535 let t = AstConv::ast_ty_to_ty(self, ast_t);
2536 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2540 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2541 let ty = self.to_ty(ast_ty);
2542 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2544 if Self::can_contain_user_lifetime_bounds(ty) {
2545 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2546 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2547 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2553 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2554 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2555 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2558 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2559 AstConv::ast_const_to_const(self, ast_c, ty)
2562 // If the type given by the user has free regions, save it for later, since
2563 // NLL would like to enforce those. Also pass in types that involve
2564 // projections, since those can resolve to `'static` bounds (modulo #54940,
2565 // which hopefully will be fixed by the time you see this comment, dear
2566 // reader, although I have my doubts). Also pass in types with inference
2567 // types, because they may be repeated. Other sorts of things are already
2568 // sufficiently enforced with erased regions. =)
2569 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2571 T: TypeFoldable<'tcx>
2573 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2576 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2577 match self.tables.borrow().node_types().get(id) {
2579 None if self.is_tainted_by_errors() => self.tcx.types.err,
2581 bug!("no type for node {}: {} in fcx {}",
2582 id, self.tcx.hir().node_to_string(id),
2588 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2589 /// outlive the region `r`.
2590 pub fn register_wf_obligation(&self,
2593 code: traits::ObligationCauseCode<'tcx>)
2595 // WF obligations never themselves fail, so no real need to give a detailed cause:
2596 let cause = traits::ObligationCause::new(span, self.body_id, code);
2597 self.register_predicate(traits::Obligation::new(cause,
2599 ty::Predicate::WellFormed(ty)));
2602 /// Registers obligations that all types appearing in `substs` are well-formed.
2603 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2604 for ty in substs.types() {
2605 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2609 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2610 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2611 /// trait/region obligations.
2613 /// For example, if there is a function:
2616 /// fn foo<'a,T:'a>(...)
2619 /// and a reference:
2625 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2626 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2627 pub fn add_obligations_for_parameters(&self,
2628 cause: traits::ObligationCause<'tcx>,
2629 predicates: &ty::InstantiatedPredicates<'tcx>)
2631 assert!(!predicates.has_escaping_bound_vars());
2633 debug!("add_obligations_for_parameters(predicates={:?})",
2636 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2637 self.register_predicate(obligation);
2641 // FIXME(arielb1): use this instead of field.ty everywhere
2642 // Only for fields! Returns <none> for methods>
2643 // Indifferent to privacy flags
2644 pub fn field_ty(&self,
2646 field: &'tcx ty::FieldDef,
2647 substs: SubstsRef<'tcx>)
2650 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2653 fn check_casts(&self) {
2654 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2655 for cast in deferred_cast_checks.drain(..) {
2660 fn resolve_generator_interiors(&self, def_id: DefId) {
2661 let mut generators = self.deferred_generator_interiors.borrow_mut();
2662 for (body_id, interior, kind) in generators.drain(..) {
2663 self.select_obligations_where_possible(false);
2664 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2668 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2669 // Non-numerics get replaced with ! or () (depending on whether
2670 // feature(never_type) is enabled, unconstrained ints with i32,
2671 // unconstrained floats with f64.
2672 // Fallback becomes very dubious if we have encountered type-checking errors.
2673 // In that case, fallback to Error.
2674 // The return value indicates whether fallback has occurred.
2675 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2676 use rustc::ty::error::UnconstrainedNumeric::Neither;
2677 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2679 assert!(ty.is_ty_infer());
2680 let fallback = match self.type_is_unconstrained_numeric(ty) {
2681 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2682 UnconstrainedInt => self.tcx.types.i32,
2683 UnconstrainedFloat => self.tcx.types.f64,
2684 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2685 Neither => return false,
2687 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2688 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2692 fn select_all_obligations_or_error(&self) {
2693 debug!("select_all_obligations_or_error");
2694 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2695 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2699 /// Select as many obligations as we can at present.
2700 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2701 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2702 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2706 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2707 /// returns a type of `&T`, but the actual type we assign to the
2708 /// *expression* is `T`. So this function just peels off the return
2709 /// type by one layer to yield `T`.
2710 fn make_overloaded_place_return_type(&self,
2711 method: MethodCallee<'tcx>)
2712 -> ty::TypeAndMut<'tcx>
2714 // extract method return type, which will be &T;
2715 let ret_ty = method.sig.output();
2717 // method returns &T, but the type as visible to user is T, so deref
2718 ret_ty.builtin_deref(true).unwrap()
2724 base_expr: &'tcx hir::Expr,
2728 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2729 // FIXME(#18741) -- this is almost but not quite the same as the
2730 // autoderef that normal method probing does. They could likely be
2733 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2734 let mut result = None;
2735 while result.is_none() && autoderef.next().is_some() {
2736 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2738 autoderef.finalize(self);
2742 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2743 /// (and otherwise adjust) `base_expr`, looking for a type which either
2744 /// supports builtin indexing or overloaded indexing.
2745 /// This loop implements one step in that search; the autoderef loop
2746 /// is implemented by `lookup_indexing`.
2750 base_expr: &hir::Expr,
2751 autoderef: &Autoderef<'a, 'tcx>,
2754 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2755 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2756 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2763 for &unsize in &[false, true] {
2764 let mut self_ty = adjusted_ty;
2766 // We only unsize arrays here.
2767 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2768 self_ty = self.tcx.mk_slice(element_ty);
2774 // If some lookup succeeds, write callee into table and extract index/element
2775 // type from the method signature.
2776 // If some lookup succeeded, install method in table
2777 let input_ty = self.next_ty_var(TypeVariableOrigin {
2778 kind: TypeVariableOriginKind::AutoDeref,
2779 span: base_expr.span,
2781 let method = self.try_overloaded_place_op(
2782 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2784 let result = method.map(|ok| {
2785 debug!("try_index_step: success, using overloaded indexing");
2786 let method = self.register_infer_ok_obligations(ok);
2788 let mut adjustments = autoderef.adjust_steps(self, needs);
2789 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2790 let mutbl = match r_mutbl {
2791 hir::MutImmutable => AutoBorrowMutability::Immutable,
2792 hir::MutMutable => AutoBorrowMutability::Mutable {
2793 // Indexing can be desugared to a method call,
2794 // so maybe we could use two-phase here.
2795 // See the documentation of AllowTwoPhase for why that's
2796 // not the case today.
2797 allow_two_phase_borrow: AllowTwoPhase::No,
2800 adjustments.push(Adjustment {
2801 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2802 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2809 adjustments.push(Adjustment {
2810 kind: Adjust::Pointer(PointerCast::Unsize),
2811 target: method.sig.inputs()[0]
2814 self.apply_adjustments(base_expr, adjustments);
2816 self.write_method_call(expr.hir_id, method);
2817 (input_ty, self.make_overloaded_place_return_type(method).ty)
2819 if result.is_some() {
2827 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2828 let (tr, name) = match (op, is_mut) {
2829 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2830 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2831 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2832 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2834 (tr, ast::Ident::with_empty_ctxt(name))
2837 fn try_overloaded_place_op(&self,
2840 arg_tys: &[Ty<'tcx>],
2843 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2845 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2851 // Try Mut first, if needed.
2852 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2853 let method = match (needs, mut_tr) {
2854 (Needs::MutPlace, Some(trait_did)) => {
2855 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2860 // Otherwise, fall back to the immutable version.
2861 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2862 let method = match (method, imm_tr) {
2863 (None, Some(trait_did)) => {
2864 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2866 (method, _) => method,
2872 fn check_method_argument_types(
2876 method: Result<MethodCallee<'tcx>, ()>,
2877 args_no_rcvr: &'tcx [hir::Expr],
2878 tuple_arguments: TupleArgumentsFlag,
2879 expected: Expectation<'tcx>,
2881 let has_error = match method {
2883 method.substs.references_error() || method.sig.references_error()
2888 let err_inputs = self.err_args(args_no_rcvr.len());
2890 let err_inputs = match tuple_arguments {
2891 DontTupleArguments => err_inputs,
2892 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2895 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2896 false, tuple_arguments, None);
2897 return self.tcx.types.err;
2900 let method = method.unwrap();
2901 // HACK(eddyb) ignore self in the definition (see above).
2902 let expected_arg_tys = self.expected_inputs_for_expected_output(
2905 method.sig.output(),
2906 &method.sig.inputs()[1..]
2908 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2909 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2910 self.tcx.hir().span_if_local(method.def_id));
2914 fn self_type_matches_expected_vid(
2916 trait_ref: ty::PolyTraitRef<'tcx>,
2917 expected_vid: ty::TyVid,
2919 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2921 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2922 trait_ref, self_ty, expected_vid
2925 ty::Infer(ty::TyVar(found_vid)) => {
2926 // FIXME: consider using `sub_root_var` here so we
2927 // can see through subtyping.
2928 let found_vid = self.root_var(found_vid);
2929 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2930 expected_vid == found_vid
2936 fn obligations_for_self_ty<'b>(
2939 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2942 // FIXME: consider using `sub_root_var` here so we
2943 // can see through subtyping.
2944 let ty_var_root = self.root_var(self_ty);
2945 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2946 self_ty, ty_var_root,
2947 self.fulfillment_cx.borrow().pending_obligations());
2951 .pending_obligations()
2953 .filter_map(move |obligation| match obligation.predicate {
2954 ty::Predicate::Projection(ref data) =>
2955 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2956 ty::Predicate::Trait(ref data) =>
2957 Some((data.to_poly_trait_ref(), obligation)),
2958 ty::Predicate::Subtype(..) => None,
2959 ty::Predicate::RegionOutlives(..) => None,
2960 ty::Predicate::TypeOutlives(..) => None,
2961 ty::Predicate::WellFormed(..) => None,
2962 ty::Predicate::ObjectSafe(..) => None,
2963 ty::Predicate::ConstEvaluatable(..) => None,
2964 // N.B., this predicate is created by breaking down a
2965 // `ClosureType: FnFoo()` predicate, where
2966 // `ClosureType` represents some `Closure`. It can't
2967 // possibly be referring to the current closure,
2968 // because we haven't produced the `Closure` for
2969 // this closure yet; this is exactly why the other
2970 // code is looking for a self type of a unresolved
2971 // inference variable.
2972 ty::Predicate::ClosureKind(..) => None,
2973 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2976 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2977 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2978 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2982 /// Generic function that factors out common logic from function calls,
2983 /// method calls and overloaded operators.
2984 fn check_argument_types(
2988 fn_inputs: &[Ty<'tcx>],
2989 expected_arg_tys: &[Ty<'tcx>],
2990 args: &'tcx [hir::Expr],
2992 tuple_arguments: TupleArgumentsFlag,
2993 def_span: Option<Span>,
2997 // Grab the argument types, supplying fresh type variables
2998 // if the wrong number of arguments were supplied
2999 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3005 // All the input types from the fn signature must outlive the call
3006 // so as to validate implied bounds.
3007 for &fn_input_ty in fn_inputs {
3008 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3011 let expected_arg_count = fn_inputs.len();
3013 let param_count_error = |expected_count: usize,
3018 let mut err = tcx.sess.struct_span_err_with_code(sp,
3019 &format!("this function takes {}{} but {} {} supplied",
3020 if c_variadic { "at least " } else { "" },
3021 potentially_plural_count(expected_count, "parameter"),
3022 potentially_plural_count(arg_count, "parameter"),
3023 if arg_count == 1 {"was"} else {"were"}),
3024 DiagnosticId::Error(error_code.to_owned()));
3026 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3027 err.span_label(def_s, "defined here");
3030 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3031 // remove closing `)` from the span
3032 let sugg_span = sugg_span.shrink_to_lo();
3033 err.span_suggestion(
3035 "expected the unit value `()`; create it with empty parentheses",
3037 Applicability::MachineApplicable);
3039 err.span_label(sp, format!("expected {}{}",
3040 if c_variadic { "at least " } else { "" },
3041 potentially_plural_count(expected_count, "parameter")));
3046 let mut expected_arg_tys = expected_arg_tys.to_vec();
3048 let formal_tys = if tuple_arguments == TupleArguments {
3049 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3050 match tuple_type.sty {
3051 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3052 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3053 expected_arg_tys = vec![];
3054 self.err_args(args.len())
3056 ty::Tuple(arg_types) => {
3057 expected_arg_tys = match expected_arg_tys.get(0) {
3058 Some(&ty) => match ty.sty {
3059 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3064 arg_types.iter().map(|k| k.expect_ty()).collect()
3067 span_err!(tcx.sess, sp, E0059,
3068 "cannot use call notation; the first type parameter \
3069 for the function trait is neither a tuple nor unit");
3070 expected_arg_tys = vec![];
3071 self.err_args(args.len())
3074 } else if expected_arg_count == supplied_arg_count {
3076 } else if c_variadic {
3077 if supplied_arg_count >= expected_arg_count {
3080 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3081 expected_arg_tys = vec![];
3082 self.err_args(supplied_arg_count)
3085 // is the missing argument of type `()`?
3086 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3087 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3088 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3089 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3093 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3095 expected_arg_tys = vec![];
3096 self.err_args(supplied_arg_count)
3099 debug!("check_argument_types: formal_tys={:?}",
3100 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3102 // If there is no expectation, expect formal_tys.
3103 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3109 // Check the arguments.
3110 // We do this in a pretty awful way: first we type-check any arguments
3111 // that are not closures, then we type-check the closures. This is so
3112 // that we have more information about the types of arguments when we
3113 // type-check the functions. This isn't really the right way to do this.
3114 for &check_closures in &[false, true] {
3115 debug!("check_closures={}", check_closures);
3117 // More awful hacks: before we check argument types, try to do
3118 // an "opportunistic" vtable resolution of any trait bounds on
3119 // the call. This helps coercions.
3121 self.select_obligations_where_possible(false);
3124 // For C-variadic functions, we don't have a declared type for all of
3125 // the arguments hence we only do our usual type checking with
3126 // the arguments who's types we do know.
3127 let t = if c_variadic {
3129 } else if tuple_arguments == TupleArguments {
3134 for (i, arg) in args.iter().take(t).enumerate() {
3135 // Warn only for the first loop (the "no closures" one).
3136 // Closure arguments themselves can't be diverging, but
3137 // a previous argument can, e.g., `foo(panic!(), || {})`.
3138 if !check_closures {
3139 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3142 let is_closure = match arg.node {
3143 ExprKind::Closure(..) => true,
3147 if is_closure != check_closures {
3151 debug!("checking the argument");
3152 let formal_ty = formal_tys[i];
3154 // The special-cased logic below has three functions:
3155 // 1. Provide as good of an expected type as possible.
3156 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3158 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3160 // 2. Coerce to the most detailed type that could be coerced
3161 // to, which is `expected_ty` if `rvalue_hint` returns an
3162 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3163 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3164 // We're processing function arguments so we definitely want to use
3165 // two-phase borrows.
3166 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3168 // 3. Relate the expected type and the formal one,
3169 // if the expected type was used for the coercion.
3170 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3174 // We also need to make sure we at least write the ty of the other
3175 // arguments which we skipped above.
3177 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3178 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3179 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3182 for arg in args.iter().skip(expected_arg_count) {
3183 let arg_ty = self.check_expr(&arg);
3185 // There are a few types which get autopromoted when passed via varargs
3186 // in C but we just error out instead and require explicit casts.
3187 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3189 ty::Float(ast::FloatTy::F32) => {
3190 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3192 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3193 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3195 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3196 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3199 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3200 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3201 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3209 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3210 vec![self.tcx.types.err; len]
3213 // AST fragment checking
3216 expected: Expectation<'tcx>)
3222 ast::LitKind::Str(..) => tcx.mk_static_str(),
3223 ast::LitKind::ByteStr(ref v) => {
3224 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3225 tcx.mk_array(tcx.types.u8, v.len() as u64))
3227 ast::LitKind::Byte(_) => tcx.types.u8,
3228 ast::LitKind::Char(_) => tcx.types.char,
3229 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3230 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3231 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3232 let opt_ty = expected.to_option(self).and_then(|ty| {
3234 ty::Int(_) | ty::Uint(_) => Some(ty),
3235 ty::Char => Some(tcx.types.u8),
3236 ty::RawPtr(..) => Some(tcx.types.usize),
3237 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3241 opt_ty.unwrap_or_else(|| self.next_int_var())
3243 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3244 ast::LitKind::FloatUnsuffixed(_) => {
3245 let opt_ty = expected.to_option(self).and_then(|ty| {
3247 ty::Float(_) => Some(ty),
3251 opt_ty.unwrap_or_else(|| self.next_float_var())
3253 ast::LitKind::Bool(_) => tcx.types.bool,
3254 ast::LitKind::Err(_) => tcx.types.err,
3258 // Determine the `Self` type, using fresh variables for all variables
3259 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3260 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3262 pub fn impl_self_ty(&self,
3263 span: Span, // (potential) receiver for this impl
3265 -> TypeAndSubsts<'tcx> {
3266 let ity = self.tcx.type_of(did);
3267 debug!("impl_self_ty: ity={:?}", ity);
3269 let substs = self.fresh_substs_for_item(span, did);
3270 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3272 TypeAndSubsts { substs: substs, ty: substd_ty }
3275 /// Unifies the output type with the expected type early, for more coercions
3276 /// and forward type information on the input expressions.
3277 fn expected_inputs_for_expected_output(&self,
3279 expected_ret: Expectation<'tcx>,
3280 formal_ret: Ty<'tcx>,
3281 formal_args: &[Ty<'tcx>])
3283 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3284 let ret_ty = match expected_ret.only_has_type(self) {
3286 None => return Vec::new()
3288 let expect_args = self.fudge_inference_if_ok(|| {
3289 // Attempt to apply a subtyping relationship between the formal
3290 // return type (likely containing type variables if the function
3291 // is polymorphic) and the expected return type.
3292 // No argument expectations are produced if unification fails.
3293 let origin = self.misc(call_span);
3294 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3296 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3297 // to identity so the resulting type is not constrained.
3300 // Process any obligations locally as much as
3301 // we can. We don't care if some things turn
3302 // out unconstrained or ambiguous, as we're
3303 // just trying to get hints here.
3304 self.save_and_restore_in_snapshot_flag(|_| {
3305 let mut fulfill = TraitEngine::new(self.tcx);
3306 for obligation in ok.obligations {
3307 fulfill.register_predicate_obligation(self, obligation);
3309 fulfill.select_where_possible(self)
3310 }).map_err(|_| ())?;
3312 Err(_) => return Err(()),
3315 // Record all the argument types, with the substitutions
3316 // produced from the above subtyping unification.
3317 Ok(formal_args.iter().map(|ty| {
3318 self.resolve_vars_if_possible(ty)
3320 }).unwrap_or_default();
3321 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3322 formal_args, formal_ret,
3323 expect_args, expected_ret);
3327 pub fn check_struct_path(&self,
3330 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3331 let path_span = match *qpath {
3332 QPath::Resolved(_, ref path) => path.span,
3333 QPath::TypeRelative(ref qself, _) => qself.span
3335 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3336 let variant = match def {
3338 self.set_tainted_by_errors();
3341 Res::Def(DefKind::Variant, _) => {
3343 ty::Adt(adt, substs) => {
3344 Some((adt.variant_of_res(def), adt.did, substs))
3346 _ => bug!("unexpected type: {:?}", ty)
3349 Res::Def(DefKind::Struct, _)
3350 | Res::Def(DefKind::Union, _)
3351 | Res::Def(DefKind::TyAlias, _)
3352 | Res::Def(DefKind::AssocTy, _)
3353 | Res::SelfTy(..) => {
3355 ty::Adt(adt, substs) if !adt.is_enum() => {
3356 Some((adt.non_enum_variant(), adt.did, substs))
3361 _ => bug!("unexpected definition: {:?}", def)
3364 if let Some((variant, did, substs)) = variant {
3365 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3366 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3368 // Check bounds on type arguments used in the path.
3369 let bounds = self.instantiate_bounds(path_span, did, substs);
3370 let cause = traits::ObligationCause::new(path_span, self.body_id,
3371 traits::ItemObligation(did));
3372 self.add_obligations_for_parameters(cause, &bounds);
3376 struct_span_err!(self.tcx.sess, path_span, E0071,
3377 "expected struct, variant or union type, found {}",
3378 ty.sort_string(self.tcx))
3379 .span_label(path_span, "not a struct")
3385 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3386 // The newly resolved definition is written into `type_dependent_defs`.
3387 fn finish_resolving_struct_path(&self,
3394 QPath::Resolved(ref maybe_qself, ref path) => {
3395 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3396 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3399 QPath::TypeRelative(ref qself, ref segment) => {
3400 let ty = self.to_ty(qself);
3402 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3407 let result = AstConv::associated_path_to_ty(
3416 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3417 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3419 // Write back the new resolution.
3420 self.write_resolution(hir_id, result);
3422 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3427 /// Resolves an associated value path into a base type and associated constant, or method
3428 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3429 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3433 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3435 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3436 let (ty, qself, item_segment) = match *qpath {
3437 QPath::Resolved(ref opt_qself, ref path) => {
3439 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3440 &path.segments[..]);
3442 QPath::TypeRelative(ref qself, ref segment) => {
3443 (self.to_ty(qself), qself, segment)
3446 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3447 // Return directly on cache hit. This is useful to avoid doubly reporting
3448 // errors with default match binding modes. See #44614.
3449 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3450 .unwrap_or(Res::Err);
3451 return (def, Some(ty), slice::from_ref(&**item_segment));
3453 let item_name = item_segment.ident;
3454 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3455 let result = match error {
3456 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3457 _ => Err(ErrorReported),
3459 if item_name.name != kw::Invalid {
3460 self.report_method_error(
3464 SelfSource::QPath(qself),
3472 // Write back the new resolution.
3473 self.write_resolution(hir_id, result);
3475 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3477 slice::from_ref(&**item_segment),
3481 pub fn check_decl_initializer(
3483 local: &'tcx hir::Local,
3484 init: &'tcx hir::Expr,
3486 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3487 // for #42640 (default match binding modes).
3490 let ref_bindings = local.pat.contains_explicit_ref_binding();
3492 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3493 if let Some(m) = ref_bindings {
3494 // Somewhat subtle: if we have a `ref` binding in the pattern,
3495 // we want to avoid introducing coercions for the RHS. This is
3496 // both because it helps preserve sanity and, in the case of
3497 // ref mut, for soundness (issue #23116). In particular, in
3498 // the latter case, we need to be clear that the type of the
3499 // referent for the reference that results is *equal to* the
3500 // type of the place it is referencing, and not some
3501 // supertype thereof.
3502 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3503 self.demand_eqtype(init.span, local_ty, init_ty);
3506 self.check_expr_coercable_to_type(init, local_ty)
3510 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3511 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3512 self.write_ty(local.hir_id, t);
3514 if let Some(ref init) = local.init {
3515 let init_ty = self.check_decl_initializer(local, &init);
3516 if init_ty.references_error() {
3517 self.write_ty(local.hir_id, init_ty);
3521 self.check_pat_walk(
3524 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3527 let pat_ty = self.node_ty(local.pat.hir_id);
3528 if pat_ty.references_error() {
3529 self.write_ty(local.hir_id, pat_ty);
3533 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3534 // Don't do all the complex logic below for `DeclItem`.
3536 hir::StmtKind::Item(..) => return,
3537 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3540 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3542 // Hide the outer diverging and `has_errors` flags.
3543 let old_diverges = self.diverges.get();
3544 let old_has_errors = self.has_errors.get();
3545 self.diverges.set(Diverges::Maybe);
3546 self.has_errors.set(false);
3549 hir::StmtKind::Local(ref l) => {
3550 self.check_decl_local(&l);
3553 hir::StmtKind::Item(_) => {}
3554 hir::StmtKind::Expr(ref expr) => {
3555 // Check with expected type of `()`.
3556 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3558 hir::StmtKind::Semi(ref expr) => {
3559 self.check_expr(&expr);
3563 // Combine the diverging and `has_error` flags.
3564 self.diverges.set(self.diverges.get() | old_diverges);
3565 self.has_errors.set(self.has_errors.get() | old_has_errors);
3568 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3569 let unit = self.tcx.mk_unit();
3570 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3572 // if the block produces a `!` value, that can always be
3573 // (effectively) coerced to unit.
3575 self.demand_suptype(blk.span, unit, ty);
3579 fn check_block_with_expected(
3581 blk: &'tcx hir::Block,
3582 expected: Expectation<'tcx>,
3585 let mut fcx_ps = self.ps.borrow_mut();
3586 let unsafety_state = fcx_ps.recurse(blk);
3587 replace(&mut *fcx_ps, unsafety_state)
3590 // In some cases, blocks have just one exit, but other blocks
3591 // can be targeted by multiple breaks. This can happen both
3592 // with labeled blocks as well as when we desugar
3593 // a `try { ... }` expression.
3597 // 'a: { if true { break 'a Err(()); } Ok(()) }
3599 // Here we would wind up with two coercions, one from
3600 // `Err(())` and the other from the tail expression
3601 // `Ok(())`. If the tail expression is omitted, that's a
3602 // "forced unit" -- unless the block diverges, in which
3603 // case we can ignore the tail expression (e.g., `'a: {
3604 // break 'a 22; }` would not force the type of the block
3606 let tail_expr = blk.expr.as_ref();
3607 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3608 let coerce = if blk.targeted_by_break {
3609 CoerceMany::new(coerce_to_ty)
3611 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3612 Some(e) => slice::from_ref(e),
3615 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3618 let prev_diverges = self.diverges.get();
3619 let ctxt = BreakableCtxt {
3620 coerce: Some(coerce),
3624 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3625 for s in &blk.stmts {
3629 // check the tail expression **without** holding the
3630 // `enclosing_breakables` lock below.
3631 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3633 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3634 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3635 let coerce = ctxt.coerce.as_mut().unwrap();
3636 if let Some(tail_expr_ty) = tail_expr_ty {
3637 let tail_expr = tail_expr.unwrap();
3638 let cause = self.cause(tail_expr.span,
3639 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3645 // Subtle: if there is no explicit tail expression,
3646 // that is typically equivalent to a tail expression
3647 // of `()` -- except if the block diverges. In that
3648 // case, there is no value supplied from the tail
3649 // expression (assuming there are no other breaks,
3650 // this implies that the type of the block will be
3653 // #41425 -- label the implicit `()` as being the
3654 // "found type" here, rather than the "expected type".
3655 if !self.diverges.get().always() {
3656 // #50009 -- Do not point at the entire fn block span, point at the return type
3657 // span, as it is the cause of the requirement, and
3658 // `consider_hint_about_removing_semicolon` will point at the last expression
3659 // if it were a relevant part of the error. This improves usability in editors
3660 // that highlight errors inline.
3661 let mut sp = blk.span;
3662 let mut fn_span = None;
3663 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3664 let ret_sp = decl.output.span();
3665 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3666 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3667 // output would otherwise be incorrect and even misleading. Make sure
3668 // the span we're aiming at correspond to a `fn` body.
3669 if block_sp == blk.span {
3671 fn_span = Some(ident.span);
3675 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3676 if let Some(expected_ty) = expected.only_has_type(self) {
3677 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3679 if let Some(fn_span) = fn_span {
3680 err.span_label(fn_span, "this function's body doesn't return");
3688 // If we can break from the block, then the block's exit is always reachable
3689 // (... as long as the entry is reachable) - regardless of the tail of the block.
3690 self.diverges.set(prev_diverges);
3693 let mut ty = ctxt.coerce.unwrap().complete(self);
3695 if self.has_errors.get() || ty.references_error() {
3696 ty = self.tcx.types.err
3699 self.write_ty(blk.hir_id, ty);
3701 *self.ps.borrow_mut() = prev;
3705 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3706 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3708 Node::Item(&hir::Item {
3709 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3711 Node::ImplItem(&hir::ImplItem {
3712 node: hir::ImplItemKind::Method(_, body_id), ..
3714 let body = self.tcx.hir().body(body_id);
3715 if let ExprKind::Block(block, _) = &body.value.node {
3716 return Some(block.span);
3724 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3725 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3726 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3727 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3730 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3731 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3733 Node::Item(&hir::Item {
3734 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3736 // This is less than ideal, it will not suggest a return type span on any
3737 // method called `main`, regardless of whether it is actually the entry point,
3738 // but it will still present it as the reason for the expected type.
3739 Some((decl, ident, ident.name != sym::main))
3741 Node::TraitItem(&hir::TraitItem {
3742 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3745 }) => Some((decl, ident, true)),
3746 Node::ImplItem(&hir::ImplItem {
3747 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3750 }) => Some((decl, ident, false)),
3755 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3756 /// suggestion can be made, `None` otherwise.
3757 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3758 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3759 // `while` before reaching it, as block tail returns are not available in them.
3760 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3761 let parent = self.tcx.hir().get(blk_id);
3762 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3766 /// On implicit return expressions with mismatched types, provides the following suggestions:
3768 /// - Points out the method's return type as the reason for the expected type.
3769 /// - Possible missing semicolon.
3770 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3771 pub fn suggest_mismatched_types_on_tail(
3773 err: &mut DiagnosticBuilder<'tcx>,
3774 expression: &'tcx hir::Expr,
3780 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3781 let mut pointing_at_return_type = false;
3782 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3783 pointing_at_return_type = self.suggest_missing_return_type(
3784 err, &fn_decl, expected, found, can_suggest);
3786 self.suggest_ref_or_into(err, expression, expected, found);
3787 pointing_at_return_type
3790 pub fn suggest_ref_or_into(
3792 err: &mut DiagnosticBuilder<'tcx>,
3797 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3798 err.span_suggestion(
3802 Applicability::MachineApplicable,
3804 } else if !self.check_for_cast(err, expr, found, expected) {
3805 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3809 let methods = self.get_conversion_methods(expr.span, expected, found);
3810 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3811 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3812 .filter_map(|(receiver, method)| {
3813 let method_call = format!(".{}()", method.ident);
3814 if receiver.ends_with(&method_call) {
3815 None // do not suggest code that is already there (#53348)
3817 let method_call_list = [".to_vec()", ".to_string()"];
3818 let sugg = if receiver.ends_with(".clone()")
3819 && method_call_list.contains(&method_call.as_str()) {
3820 let max_len = receiver.rfind(".").unwrap();
3821 format!("{}{}", &receiver[..max_len], method_call)
3823 format!("{}{}", receiver, method_call)
3825 Some(if is_struct_pat_shorthand_field {
3826 format!("{}: {}", receiver, sugg)
3832 if suggestions.peek().is_some() {
3833 err.span_suggestions(
3835 "try using a conversion method",
3837 Applicability::MaybeIncorrect,
3844 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3848 /// bar_that_returns_u32()
3852 /// This routine checks if the return expression in a block would make sense on its own as a
3853 /// statement and the return type has been left as default or has been specified as `()`. If so,
3854 /// it suggests adding a semicolon.
3855 fn suggest_missing_semicolon(
3857 err: &mut DiagnosticBuilder<'tcx>,
3858 expression: &'tcx hir::Expr,
3862 if expected.is_unit() {
3863 // `BlockTailExpression` only relevant if the tail expr would be
3864 // useful on its own.
3865 match expression.node {
3866 ExprKind::Call(..) |
3867 ExprKind::MethodCall(..) |
3868 ExprKind::Loop(..) |
3869 ExprKind::Match(..) |
3870 ExprKind::Block(..) => {
3871 let sp = self.tcx.sess.source_map().next_point(cause_span);
3872 err.span_suggestion(
3874 "try adding a semicolon",
3876 Applicability::MachineApplicable);
3883 /// A possible error is to forget to add a return type that is needed:
3887 /// bar_that_returns_u32()
3891 /// This routine checks if the return type is left as default, the method is not part of an
3892 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3894 fn suggest_missing_return_type(
3896 err: &mut DiagnosticBuilder<'tcx>,
3897 fn_decl: &hir::FnDecl,
3902 // Only suggest changing the return type for methods that
3903 // haven't set a return type at all (and aren't `fn main()` or an impl).
3904 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3905 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3906 err.span_suggestion(
3908 "try adding a return type",
3909 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3910 Applicability::MachineApplicable);
3913 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3914 err.span_label(span, "possibly return type missing here?");
3917 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3918 // `fn main()` must return `()`, do not suggest changing return type
3919 err.span_label(span, "expected `()` because of default return type");
3922 // expectation was caused by something else, not the default return
3923 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3924 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3925 // Only point to return type if the expected type is the return type, as if they
3926 // are not, the expectation must have been caused by something else.
3927 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3929 let ty = AstConv::ast_ty_to_ty(self, ty);
3930 debug!("suggest_missing_return_type: return type {:?}", ty);
3931 debug!("suggest_missing_return_type: expected type {:?}", ty);
3932 if ty.sty == expected.sty {
3933 err.span_label(sp, format!("expected `{}` because of return type",
3942 /// A possible error is to forget to add `.await` when using futures:
3945 /// #![feature(async_await)]
3947 /// async fn make_u32() -> u32 {
3951 /// fn take_u32(x: u32) {}
3953 /// async fn foo() {
3954 /// let x = make_u32();
3959 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3960 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3961 /// `.await` to the tail of the expression.
3962 fn suggest_missing_await(
3964 err: &mut DiagnosticBuilder<'tcx>,
3969 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3970 // body isn't `async`.
3971 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3972 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3973 let body = self.tcx().hir().body(body_id);
3974 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3976 // Check for `Future` implementations by constructing a predicate to
3977 // prove: `<T as Future>::Output == U`
3978 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3979 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3980 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3981 // `<T as Future>::Output`
3982 projection_ty: ty::ProjectionTy {
3984 substs: self.tcx.mk_substs_trait(
3986 self.fresh_substs_for_item(sp, item_def_id)
3993 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
3994 if self.infcx.predicate_may_hold(&obligation) {
3995 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
3996 err.span_suggestion(
3998 "consider using `.await` here",
3999 format!("{}.await", code),
4000 Applicability::MaybeIncorrect,
4008 /// A common error is to add an extra semicolon:
4011 /// fn foo() -> usize {
4016 /// This routine checks if the final statement in a block is an
4017 /// expression with an explicit semicolon whose type is compatible
4018 /// with `expected_ty`. If so, it suggests removing the semicolon.
4019 fn consider_hint_about_removing_semicolon(
4021 blk: &'tcx hir::Block,
4022 expected_ty: Ty<'tcx>,
4023 err: &mut DiagnosticBuilder<'_>,
4025 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4026 err.span_suggestion(
4028 "consider removing this semicolon",
4030 Applicability::MachineApplicable,
4035 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4036 // Be helpful when the user wrote `{... expr;}` and
4037 // taking the `;` off is enough to fix the error.
4038 let last_stmt = blk.stmts.last()?;
4039 let last_expr = match last_stmt.node {
4040 hir::StmtKind::Semi(ref e) => e,
4043 let last_expr_ty = self.node_ty(last_expr.hir_id);
4044 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4047 let original_span = original_sp(last_stmt.span, blk.span);
4048 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4051 // Instantiates the given path, which must refer to an item with the given
4052 // number of type parameters and type.
4053 pub fn instantiate_value_path(&self,
4054 segments: &[hir::PathSegment],
4055 self_ty: Option<Ty<'tcx>>,
4059 -> (Ty<'tcx>, Res) {
4061 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4070 let path_segs = match res {
4071 Res::Local(_) | Res::SelfCtor(_) => vec![],
4072 Res::Def(kind, def_id) =>
4073 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4074 _ => bug!("instantiate_value_path on {:?}", res),
4077 let mut user_self_ty = None;
4078 let mut is_alias_variant_ctor = false;
4080 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4081 if let Some(self_ty) = self_ty {
4082 let adt_def = self_ty.ty_adt_def().unwrap();
4083 user_self_ty = Some(UserSelfTy {
4084 impl_def_id: adt_def.did,
4087 is_alias_variant_ctor = true;
4090 Res::Def(DefKind::Method, def_id)
4091 | Res::Def(DefKind::AssocConst, def_id) => {
4092 let container = tcx.associated_item(def_id).container;
4093 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4095 ty::TraitContainer(trait_did) => {
4096 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4098 ty::ImplContainer(impl_def_id) => {
4099 if segments.len() == 1 {
4100 // `<T>::assoc` will end up here, and so
4101 // can `T::assoc`. It this came from an
4102 // inherent impl, we need to record the
4103 // `T` for posterity (see `UserSelfTy` for
4105 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4106 user_self_ty = Some(UserSelfTy {
4117 // Now that we have categorized what space the parameters for each
4118 // segment belong to, let's sort out the parameters that the user
4119 // provided (if any) into their appropriate spaces. We'll also report
4120 // errors if type parameters are provided in an inappropriate place.
4122 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4123 let generics_has_err = AstConv::prohibit_generics(
4124 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4125 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4132 if let Res::Local(hid) = res {
4133 let ty = self.local_ty(span, hid).decl_ty;
4134 let ty = self.normalize_associated_types_in(span, &ty);
4135 self.write_ty(hir_id, ty);
4139 if generics_has_err {
4140 // Don't try to infer type parameters when prohibited generic arguments were given.
4141 user_self_ty = None;
4144 // Now we have to compare the types that the user *actually*
4145 // provided against the types that were *expected*. If the user
4146 // did not provide any types, then we want to substitute inference
4147 // variables. If the user provided some types, we may still need
4148 // to add defaults. If the user provided *too many* types, that's
4151 let mut infer_args_for_err = FxHashSet::default();
4152 for &PathSeg(def_id, index) in &path_segs {
4153 let seg = &segments[index];
4154 let generics = tcx.generics_of(def_id);
4155 // Argument-position `impl Trait` is treated as a normal generic
4156 // parameter internally, but we don't allow users to specify the
4157 // parameter's value explicitly, so we have to do some error-
4159 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4164 false, // `is_method_call`
4166 if suppress_errors {
4167 infer_args_for_err.insert(index);
4168 self.set_tainted_by_errors(); // See issue #53251.
4172 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4173 tcx.generics_of(*def_id).has_self
4174 }).unwrap_or(false);
4176 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4177 let ty = self.impl_self_ty(span, impl_def_id).ty;
4178 let adt_def = ty.ty_adt_def();
4181 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4182 let variant = adt_def.non_enum_variant();
4183 let ctor_def_id = variant.ctor_def_id.unwrap();
4185 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4190 let mut err = tcx.sess.struct_span_err(span,
4191 "the `Self` constructor can only be used with tuple or unit structs");
4192 if let Some(adt_def) = adt_def {
4193 match adt_def.adt_kind() {
4195 err.help("did you mean to use one of the enum's variants?");
4199 err.span_suggestion(
4201 "use curly brackets",
4202 String::from("Self { /* fields */ }"),
4203 Applicability::HasPlaceholders,
4210 return (tcx.types.err, res)
4216 let def_id = res.def_id();
4218 // The things we are substituting into the type should not contain
4219 // escaping late-bound regions, and nor should the base type scheme.
4220 let ty = tcx.type_of(def_id);
4222 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4228 // Provide the generic args, and whether types should be inferred.
4230 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4233 // If we've encountered an `impl Trait`-related error, we're just
4234 // going to infer the arguments for better error messages.
4235 if !infer_args_for_err.contains(&index) {
4236 // Check whether the user has provided generic arguments.
4237 if let Some(ref data) = segments[index].args {
4238 return (Some(data), segments[index].infer_args);
4241 return (None, segments[index].infer_args);
4246 // Provide substitutions for parameters for which (valid) arguments have been provided.
4248 match (¶m.kind, arg) {
4249 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4250 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4252 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4253 self.to_ty(ty).into()
4255 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4256 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4258 _ => unreachable!(),
4261 // Provide substitutions for parameters for which arguments are inferred.
4262 |substs, param, infer_args| {
4264 GenericParamDefKind::Lifetime => {
4265 self.re_infer(Some(param), span).unwrap().into()
4267 GenericParamDefKind::Type { has_default, .. } => {
4268 if !infer_args && has_default {
4269 // If we have a default, then we it doesn't matter that we're not
4270 // inferring the type arguments: we provide the default where any
4272 let default = tcx.type_of(param.def_id);
4275 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4278 // If no type arguments were provided, we have to infer them.
4279 // This case also occurs as a result of some malformed input, e.g.
4280 // a lifetime argument being given instead of a type parameter.
4281 // Using inference instead of `Error` gives better error messages.
4282 self.var_for_def(span, param)
4285 GenericParamDefKind::Const => {
4286 // FIXME(const_generics:defaults)
4287 // No const parameters were provided, we have to infer them.
4288 self.var_for_def(span, param)
4293 assert!(!substs.has_escaping_bound_vars());
4294 assert!(!ty.has_escaping_bound_vars());
4296 // First, store the "user substs" for later.
4297 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4299 // Add all the obligations that are required, substituting and
4300 // normalized appropriately.
4301 let bounds = self.instantiate_bounds(span, def_id, &substs);
4302 self.add_obligations_for_parameters(
4303 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4306 // Substitute the values for the type parameters into the type of
4307 // the referenced item.
4308 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4310 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4311 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4312 // is inherent, there is no `Self` parameter; instead, the impl needs
4313 // type parameters, which we can infer by unifying the provided `Self`
4314 // with the substituted impl type.
4315 // This also occurs for an enum variant on a type alias.
4316 let ty = tcx.type_of(impl_def_id);
4318 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4319 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4320 Ok(ok) => self.register_infer_ok_obligations(ok),
4322 self.tcx.sess.delay_span_bug(span, &format!(
4323 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4331 self.check_rustc_args_require_const(def_id, hir_id, span);
4333 debug!("instantiate_value_path: type of {:?} is {:?}",
4336 self.write_substs(hir_id, substs);
4338 (ty_substituted, res)
4341 fn check_rustc_args_require_const(&self,
4345 // We're only interested in functions tagged with
4346 // #[rustc_args_required_const], so ignore anything that's not.
4347 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4351 // If our calling expression is indeed the function itself, we're good!
4352 // If not, generate an error that this can only be called directly.
4353 if let Node::Expr(expr) = self.tcx.hir().get(
4354 self.tcx.hir().get_parent_node(hir_id))
4356 if let ExprKind::Call(ref callee, ..) = expr.node {
4357 if callee.hir_id == hir_id {
4363 self.tcx.sess.span_err(span, "this function can only be invoked \
4364 directly, not through a function pointer");
4367 // Resolves `typ` by a single level if `typ` is a type variable.
4368 // If no resolution is possible, then an error is reported.
4369 // Numeric inference variables may be left unresolved.
4370 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4371 let ty = self.resolve_type_vars_with_obligations(ty);
4372 if !ty.is_ty_var() {
4375 if !self.is_tainted_by_errors() {
4376 self.need_type_info_err((**self).body_id, sp, ty)
4377 .note("type must be known at this point")
4380 self.demand_suptype(sp, self.tcx.types.err, ty);
4385 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4388 ctxt: BreakableCtxt<'tcx>,
4390 ) -> (BreakableCtxt<'tcx>, R) {
4393 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4394 index = enclosing_breakables.stack.len();
4395 enclosing_breakables.by_id.insert(id, index);
4396 enclosing_breakables.stack.push(ctxt);
4400 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4401 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4402 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4403 enclosing_breakables.stack.pop().expect("missing breakable context")
4408 /// Instantiate a QueryResponse in a probe context, without a
4409 /// good ObligationCause.
4410 fn probe_instantiate_query_response(
4413 original_values: &OriginalQueryValues<'tcx>,
4414 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4415 ) -> InferResult<'tcx, Ty<'tcx>>
4417 self.instantiate_query_response_and_region_obligations(
4418 &traits::ObligationCause::misc(span, self.body_id),
4424 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4425 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4426 let mut contained_in_place = false;
4428 while let hir::Node::Expr(parent_expr) =
4429 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4431 match &parent_expr.node {
4432 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4433 if lhs.hir_id == expr_id {
4434 contained_in_place = true;
4440 expr_id = parent_expr.hir_id;
4447 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4448 let own_counts = generics.own_counts();
4450 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4456 if own_counts.types == 0 {
4460 // Make a vector of booleans initially `false`; set to `true` when used.
4461 let mut types_used = vec![false; own_counts.types];
4463 for leaf_ty in ty.walk() {
4464 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4465 debug!("found use of ty param num {}", index);
4466 types_used[index as usize - own_counts.lifetimes] = true;
4467 } else if let ty::Error = leaf_ty.sty {
4468 // If there is already another error, do not emit
4469 // an error for not using a type parameter.
4470 assert!(tcx.sess.has_errors());
4475 let types = generics.params.iter().filter(|param| match param.kind {
4476 ty::GenericParamDefKind::Type { .. } => true,
4479 for (&used, param) in types_used.iter().zip(types) {
4481 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4482 let span = tcx.hir().span(id);
4483 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4484 .span_label(span, "unused type parameter")
4490 fn fatally_break_rust(sess: &Session) {
4491 let handler = sess.diagnostic();
4492 handler.span_bug_no_panic(
4494 "It looks like you're trying to break rust; would you like some ICE?",
4496 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4497 handler.note_without_error(
4498 "we would appreciate a joke overview: \
4499 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4501 handler.note_without_error(&format!("rustc {} running on {}",
4502 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4503 crate::session::config::host_triple(),
4507 fn potentially_plural_count(count: usize, word: &str) -> String {
4508 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })