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 crate::middle::lang_items;
97 use crate::namespace::Namespace;
98 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
99 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
100 use rustc_data_structures::indexed_vec::Idx;
101 use rustc_target::spec::abi::Abi;
102 use rustc::infer::opaque_types::OpaqueTypeDecl;
103 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
104 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
105 use rustc::middle::region;
106 use rustc::mir::interpret::{ConstValue, GlobalId};
107 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
109 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
110 ToPolyTraitRef, ToPredicate, RegionKind, UserType
112 use rustc::ty::adjustment::{
113 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
115 use rustc::ty::fold::TypeFoldable;
116 use rustc::ty::query::Providers;
117 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
118 use rustc::ty::util::{Representability, IntTypeExt, Discr};
119 use rustc::ty::layout::VariantIdx;
120 use syntax_pos::{self, BytePos, Span, MultiSpan};
121 use syntax_pos::hygiene::CompilerDesugaringKind;
124 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>)>>,
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 err_count_on_creation: usize,
532 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
533 ret_coercion_span: RefCell<Option<Span>>,
535 yield_ty: Option<Ty<'tcx>>,
537 ps: RefCell<UnsafetyState>,
539 /// Whether the last checked node generates a divergence (e.g.,
540 /// `return` will set this to `Always`). In general, when entering
541 /// an expression or other node in the tree, the initial value
542 /// indicates whether prior parts of the containing expression may
543 /// have diverged. It is then typically set to `Maybe` (and the
544 /// old value remembered) for processing the subparts of the
545 /// current expression. As each subpart is processed, they may set
546 /// the flag to `Always`, etc. Finally, at the end, we take the
547 /// result and "union" it with the original value, so that when we
548 /// return the flag indicates if any subpart of the parent
549 /// expression (up to and including this part) has diverged. So,
550 /// if you read it after evaluating a subexpression `X`, the value
551 /// you get indicates whether any subexpression that was
552 /// evaluating up to and including `X` diverged.
554 /// We currently use this flag only for diagnostic purposes:
556 /// - To warn about unreachable code: if, after processing a
557 /// sub-expression but before we have applied the effects of the
558 /// current node, we see that the flag is set to `Always`, we
559 /// can issue a warning. This corresponds to something like
560 /// `foo(return)`; we warn on the `foo()` expression. (We then
561 /// update the flag to `WarnedAlways` to suppress duplicate
562 /// reports.) Similarly, if we traverse to a fresh statement (or
563 /// tail expression) from a `Always` setting, we will issue a
564 /// warning. This corresponds to something like `{return;
565 /// foo();}` or `{return; 22}`, where we would warn on the
568 /// An expression represents dead code if, after checking it,
569 /// the diverges flag is set to something other than `Maybe`.
570 diverges: Cell<Diverges>,
572 /// Whether any child nodes have any type errors.
573 has_errors: Cell<bool>,
575 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
577 inh: &'a Inherited<'a, 'tcx>,
580 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
581 type Target = Inherited<'a, 'tcx>;
582 fn deref(&self) -> &Self::Target {
587 /// Helper type of a temporary returned by `Inherited::build(...)`.
588 /// Necessary because we can't write the following bound:
589 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
590 pub struct InheritedBuilder<'tcx> {
591 infcx: infer::InferCtxtBuilder<'tcx>,
595 impl Inherited<'_, 'tcx> {
596 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
597 let hir_id_root = if def_id.is_local() {
598 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
599 DefId::local(hir_id.owner)
605 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
611 impl<'tcx> InheritedBuilder<'tcx> {
612 fn enter<F, R>(&mut self, f: F) -> R
614 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
616 let def_id = self.def_id;
617 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
621 impl Inherited<'a, 'tcx> {
622 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
624 let item_id = tcx.hir().as_local_hir_id(def_id);
625 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
626 let implicit_region_bound = body_id.map(|body_id| {
627 let body = tcx.hir().body(body_id);
628 tcx.mk_region(ty::ReScope(region::Scope {
629 id: body.value.hir_id.local_id,
630 data: region::ScopeData::CallSite
635 tables: MaybeInProgressTables {
636 maybe_tables: infcx.in_progress_tables,
639 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
640 locals: RefCell::new(Default::default()),
641 deferred_sized_obligations: RefCell::new(Vec::new()),
642 deferred_call_resolutions: RefCell::new(Default::default()),
643 deferred_cast_checks: RefCell::new(Vec::new()),
644 deferred_generator_interiors: RefCell::new(Vec::new()),
645 opaque_types: RefCell::new(Default::default()),
646 implicit_region_bound,
651 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
652 debug!("register_predicate({:?})", obligation);
653 if obligation.has_escaping_bound_vars() {
654 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
659 .register_predicate_obligation(self, obligation);
662 fn register_predicates<I>(&self, obligations: I)
663 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
665 for obligation in obligations {
666 self.register_predicate(obligation);
670 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
671 self.register_predicates(infer_ok.obligations);
675 fn normalize_associated_types_in<T>(&self,
678 param_env: ty::ParamEnv<'tcx>,
680 where T : TypeFoldable<'tcx>
682 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
683 self.register_infer_ok_obligations(ok)
687 struct CheckItemTypesVisitor<'tcx> {
691 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
692 fn visit_item(&mut self, i: &'tcx hir::Item) {
693 check_item_type(self.tcx, i);
695 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
696 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
699 pub fn check_wf_new<'tcx>(tcx: TyCtxt<'tcx>) -> Result<(), ErrorReported> {
700 tcx.sess.track_errors(|| {
701 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
702 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
706 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: DefId) {
707 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
710 fn typeck_item_bodies<'tcx>(tcx: TyCtxt<'tcx>, 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>(tcx: TyCtxt<'tcx>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed<'tcx>(tcx: TyCtxt<'tcx>, 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>(tcx: TyCtxt<'tcx>, 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.
758 fn primary_body_of<'tcx>(
761 ) -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)> {
762 match tcx.hir().get_by_hir_id(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>(tcx: TyCtxt<'tcx>, 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>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx DefIdSet {
812 &*tcx.typeck_tables_of(def_id).used_trait_imports
815 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx ty::TypeckTables<'tcx> {
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(
865 // Gather locals in statics (because of block expressions).
866 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
868 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
870 fcx.write_ty(id, revealed_ty);
875 // All type checking constraints were added, try to fallback unsolved variables.
876 fcx.select_obligations_where_possible(false);
877 let mut fallback_has_occurred = false;
878 for ty in &fcx.unsolved_variables() {
879 fallback_has_occurred |= fcx.fallback_if_possible(ty);
881 fcx.select_obligations_where_possible(fallback_has_occurred);
883 // Even though coercion casts provide type hints, we check casts after fallback for
884 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
887 // Closure and generator analysis may run after fallback
888 // because they don't constrain other type variables.
889 fcx.closure_analyze(body);
890 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
891 fcx.resolve_generator_interiors(def_id);
893 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
894 let ty = fcx.normalize_ty(span, ty);
895 fcx.require_type_is_sized(ty, span, code);
897 fcx.select_all_obligations_or_error();
899 if fn_decl.is_some() {
900 fcx.regionck_fn(id, body);
902 fcx.regionck_expr(body);
905 fcx.resolve_type_vars_in_body(body)
908 // Consistency check our TypeckTables instance can hold all ItemLocalIds
909 // it will need to hold.
910 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
915 fn check_abi<'tcx>(tcx: TyCtxt<'tcx>, span: Span, abi: Abi) {
916 if !tcx.sess.target.target.is_abi_supported(abi) {
917 struct_span_err!(tcx.sess, span, E0570,
918 "The ABI `{}` is not supported for the current target", abi).emit()
922 struct GatherLocalsVisitor<'a, 'tcx> {
923 fcx: &'a FnCtxt<'a, 'tcx>,
924 parent_id: hir::HirId,
927 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
928 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
931 // infer the variable's type
932 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
933 kind: TypeVariableOriginKind::TypeInference,
936 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
943 // take type that the user specified
944 self.fcx.locals.borrow_mut().insert(nid, typ);
951 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
952 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
953 NestedVisitorMap::None
956 // Add explicitly-declared locals.
957 fn visit_local(&mut self, local: &'tcx hir::Local) {
958 let local_ty = match local.ty {
960 let o_ty = self.fcx.to_ty(&ty);
962 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
963 self.fcx.instantiate_opaque_types_from_value(
971 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
972 &UserType::Ty(revealed_ty)
974 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
975 ty.hir_id, o_ty, revealed_ty, c_ty);
976 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
978 Some(LocalTy { decl_ty: o_ty, revealed_ty })
982 self.assign(local.span, local.hir_id, local_ty);
984 debug!("Local variable {:?} is assigned type {}",
986 self.fcx.ty_to_string(
987 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
988 intravisit::walk_local(self, local);
991 // Add pattern bindings.
992 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
993 if let PatKind::Binding(_, _, ident, _) = p.node {
994 let var_ty = self.assign(p.span, p.hir_id, None);
996 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
997 if !self.fcx.tcx.features().unsized_locals {
998 self.fcx.require_type_is_sized(var_ty, p.span,
999 traits::VariableType(node_id));
1002 debug!("Pattern binding {} is assigned to {} with type {:?}",
1004 self.fcx.ty_to_string(
1005 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1008 intravisit::walk_pat(self, p);
1011 // Don't descend into the bodies of nested closures
1014 _: intravisit::FnKind<'tcx>,
1015 _: &'tcx hir::FnDecl,
1022 /// When `check_fn` is invoked on a generator (i.e., a body that
1023 /// includes yield), it returns back some information about the yield
1025 struct GeneratorTypes<'tcx> {
1026 /// Type of value that is yielded.
1029 /// Types that are captured (see `GeneratorInterior` for more).
1032 /// Indicates if the generator is movable or static (immovable).
1033 movability: hir::GeneratorMovability,
1036 /// Helper used for fns and closures. Does the grungy work of checking a function
1037 /// body and returns the function context used for that purpose, since in the case of a fn item
1038 /// there is still a bit more to do.
1041 /// * inherited: other fields inherited from the enclosing fn (if any)
1042 fn check_fn<'a, 'tcx>(
1043 inherited: &'a Inherited<'a, 'tcx>,
1044 param_env: ty::ParamEnv<'tcx>,
1045 fn_sig: ty::FnSig<'tcx>,
1046 decl: &'tcx hir::FnDecl,
1048 body: &'tcx hir::Body,
1049 can_be_generator: Option<hir::GeneratorMovability>,
1050 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1051 let mut fn_sig = fn_sig.clone();
1053 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1055 // Create the function context. This is either derived from scratch or,
1056 // in the case of closures, based on the outer context.
1057 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1058 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1060 let declared_ret_ty = fn_sig.output();
1061 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1062 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1063 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1064 fn_sig = fcx.tcx.mk_fn_sig(
1065 fn_sig.inputs().iter().cloned(),
1072 let span = body.value.span;
1074 if body.is_generator && can_be_generator.is_some() {
1075 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1076 kind: TypeVariableOriginKind::TypeInference,
1079 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1080 fcx.yield_ty = Some(yield_ty);
1083 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1084 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1085 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1087 // Add formal parameters.
1088 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1089 // Check the pattern.
1090 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1091 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1093 // Check that argument is Sized.
1094 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1095 // for simple cases like `fn foo(x: Trait)`,
1096 // where we would error once on the parameter as a whole, and once on the binding `x`.
1097 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1098 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1101 fcx.write_ty(arg.hir_id, arg_ty);
1104 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1106 fcx.check_return_expr(&body.value);
1108 // We insert the deferred_generator_interiors entry after visiting the body.
1109 // This ensures that all nested generators appear before the entry of this generator.
1110 // resolve_generator_interiors relies on this property.
1111 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1112 let interior = fcx.next_ty_var(TypeVariableOrigin {
1113 kind: TypeVariableOriginKind::MiscVariable,
1116 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1117 Some(GeneratorTypes {
1118 yield_ty: fcx.yield_ty.unwrap(),
1120 movability: can_be_generator.unwrap(),
1126 // Finalize the return check by taking the LUB of the return types
1127 // we saw and assigning it to the expected return type. This isn't
1128 // really expected to fail, since the coercions would have failed
1129 // earlier when trying to find a LUB.
1131 // However, the behavior around `!` is sort of complex. In the
1132 // event that the `actual_return_ty` comes back as `!`, that
1133 // indicates that the fn either does not return or "returns" only
1134 // values of type `!`. In this case, if there is an expected
1135 // return type that is *not* `!`, that should be ok. But if the
1136 // return type is being inferred, we want to "fallback" to `!`:
1138 // let x = move || panic!();
1140 // To allow for that, I am creating a type variable with diverging
1141 // fallback. This was deemed ever so slightly better than unifying
1142 // the return value with `!` because it allows for the caller to
1143 // make more assumptions about the return type (e.g., they could do
1145 // let y: Option<u32> = Some(x());
1147 // which would then cause this return type to become `u32`, not
1149 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1150 let mut actual_return_ty = coercion.complete(&fcx);
1151 if actual_return_ty.is_never() {
1152 actual_return_ty = fcx.next_diverging_ty_var(
1153 TypeVariableOrigin {
1154 kind: TypeVariableOriginKind::DivergingFn,
1159 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1161 // Check that the main return type implements the termination trait.
1162 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1163 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1164 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1165 if main_id == fn_id {
1166 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1167 let trait_ref = ty::TraitRef::new(term_id, substs);
1168 let return_ty_span = decl.output.span();
1169 let cause = traits::ObligationCause::new(
1170 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1172 inherited.register_predicate(
1173 traits::Obligation::new(
1174 cause, param_env, trait_ref.to_predicate()));
1179 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1180 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1181 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1182 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1183 // at this point we don't care if there are duplicate handlers or if the handler has
1184 // the wrong signature as this value we'll be used when writing metadata and that
1185 // only happens if compilation succeeded
1186 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1188 if declared_ret_ty.sty != ty::Never {
1189 fcx.tcx.sess.span_err(
1191 "return type should be `!`",
1195 let inputs = fn_sig.inputs();
1196 let span = fcx.tcx.hir().span(fn_id);
1197 if inputs.len() == 1 {
1198 let arg_is_panic_info = match inputs[0].sty {
1199 ty::Ref(region, ty, mutbl) => match ty.sty {
1200 ty::Adt(ref adt, _) => {
1201 adt.did == panic_info_did &&
1202 mutbl == hir::Mutability::MutImmutable &&
1203 *region != RegionKind::ReStatic
1210 if !arg_is_panic_info {
1211 fcx.tcx.sess.span_err(
1212 decl.inputs[0].span,
1213 "argument should be `&PanicInfo`",
1217 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1218 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1219 if !generics.params.is_empty() {
1220 fcx.tcx.sess.span_err(
1222 "should have no type parameters",
1228 let span = fcx.tcx.sess.source_map().def_span(span);
1229 fcx.tcx.sess.span_err(span, "function should have one argument");
1232 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1237 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1238 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1239 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1240 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1241 if declared_ret_ty.sty != ty::Never {
1242 fcx.tcx.sess.span_err(
1244 "return type should be `!`",
1248 let inputs = fn_sig.inputs();
1249 let span = fcx.tcx.hir().span(fn_id);
1250 if inputs.len() == 1 {
1251 let arg_is_alloc_layout = match inputs[0].sty {
1252 ty::Adt(ref adt, _) => {
1253 adt.did == alloc_layout_did
1258 if !arg_is_alloc_layout {
1259 fcx.tcx.sess.span_err(
1260 decl.inputs[0].span,
1261 "argument should be `Layout`",
1265 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1266 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1267 if !generics.params.is_empty() {
1268 fcx.tcx.sess.span_err(
1270 "`#[alloc_error_handler]` function should have no type \
1277 let span = fcx.tcx.sess.source_map().def_span(span);
1278 fcx.tcx.sess.span_err(span, "function should have one argument");
1281 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1289 fn check_struct<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) {
1290 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1291 let def = tcx.adt_def(def_id);
1292 def.destructor(tcx); // force the destructor to be evaluated
1293 check_representable(tcx, span, def_id);
1295 if def.repr.simd() {
1296 check_simd(tcx, span, def_id);
1299 check_transparent(tcx, span, def_id);
1300 check_packed(tcx, span, def_id);
1303 fn check_union<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId, span: Span) {
1304 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1305 let def = tcx.adt_def(def_id);
1306 def.destructor(tcx); // force the destructor to be evaluated
1307 check_representable(tcx, span, def_id);
1308 check_transparent(tcx, span, def_id);
1309 check_packed(tcx, span, def_id);
1312 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1313 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1314 let mut err = struct_span_err!(
1315 tcx.sess, span, E0720,
1316 "opaque type expands to a recursive type",
1318 err.span_label(span, "expands to self-referential type");
1319 if let ty::Opaque(..) = partially_expanded_type.sty {
1320 err.note("type resolves to itself");
1322 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1328 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1330 "check_item_type(it.hir_id={}, it.name={})",
1332 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1334 let _indenter = indenter();
1336 // Consts can play a role in type-checking, so they are included here.
1337 hir::ItemKind::Static(..) => {
1338 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1339 tcx.typeck_tables_of(def_id);
1340 maybe_check_static_with_link_section(tcx, def_id, it.span);
1342 hir::ItemKind::Const(..) => {
1343 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1345 hir::ItemKind::Enum(ref enum_definition, _) => {
1346 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1348 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1349 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1350 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1351 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1352 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1353 check_impl_items_against_trait(
1360 let trait_def_id = impl_trait_ref.def_id;
1361 check_on_unimplemented(tcx, trait_def_id, it);
1364 hir::ItemKind::Trait(..) => {
1365 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1366 check_on_unimplemented(tcx, def_id, it);
1368 hir::ItemKind::Struct(..) => {
1369 check_struct(tcx, it.hir_id, it.span);
1371 hir::ItemKind::Union(..) => {
1372 check_union(tcx, it.hir_id, it.span);
1374 hir::ItemKind::Existential(..) => {
1375 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1377 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1378 check_opaque(tcx, def_id, substs, it.span);
1380 hir::ItemKind::Ty(..) => {
1381 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1382 let pty_ty = tcx.type_of(def_id);
1383 let generics = tcx.generics_of(def_id);
1384 check_bounds_are_used(tcx, &generics, pty_ty);
1386 hir::ItemKind::ForeignMod(ref m) => {
1387 check_abi(tcx, it.span, m.abi);
1389 if m.abi == Abi::RustIntrinsic {
1390 for item in &m.items {
1391 intrinsic::check_intrinsic_type(tcx, item);
1393 } else if m.abi == Abi::PlatformIntrinsic {
1394 for item in &m.items {
1395 intrinsic::check_platform_intrinsic_type(tcx, item);
1398 for item in &m.items {
1399 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1400 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1401 let mut err = struct_span_err!(
1405 "foreign items may not have type parameters"
1407 err.span_label(item.span, "can't have type parameters");
1408 // FIXME: once we start storing spans for type arguments, turn this into a
1411 "use specialization instead of type parameters by replacing them \
1412 with concrete types like `u32`",
1417 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1418 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1423 _ => { /* nothing to do */ }
1427 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1428 // Only restricted on wasm32 target for now
1429 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1433 // If `#[link_section]` is missing, then nothing to verify
1434 let attrs = tcx.codegen_fn_attrs(id);
1435 if attrs.link_section.is_none() {
1439 // For the wasm32 target statics with #[link_section] are placed into custom
1440 // sections of the final output file, but this isn't link custom sections of
1441 // other executable formats. Namely we can only embed a list of bytes,
1442 // nothing with pointers to anything else or relocations. If any relocation
1443 // show up, reject them here.
1444 let instance = ty::Instance::mono(tcx, id);
1445 let cid = GlobalId {
1449 let param_env = ty::ParamEnv::reveal_all();
1450 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1451 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1454 bug!("Matching on non-ByRef static")
1456 if alloc.relocations.len() != 0 {
1457 let msg = "statics with a custom `#[link_section]` must be a \
1458 simple list of bytes on the wasm target with no \
1459 extra levels of indirection such as references";
1460 tcx.sess.span_err(span, msg);
1465 fn check_on_unimplemented<'tcx>(tcx: TyCtxt<'tcx>, trait_def_id: DefId, item: &hir::Item) {
1466 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1467 // an error would be reported if this fails.
1468 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1471 fn report_forbidden_specialization<'tcx>(
1473 impl_item: &hir::ImplItem,
1476 let mut err = struct_span_err!(
1477 tcx.sess, impl_item.span, E0520,
1478 "`{}` specializes an item from a parent `impl`, but \
1479 that item is not marked `default`",
1481 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1484 match tcx.span_of_impl(parent_impl) {
1486 err.span_label(span, "parent `impl` is here");
1487 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1491 err.note(&format!("parent implementation is in crate `{}`", cname));
1498 fn check_specialization_validity<'tcx>(
1500 trait_def: &ty::TraitDef,
1501 trait_item: &ty::AssocItem,
1503 impl_item: &hir::ImplItem,
1505 let ancestors = trait_def.ancestors(tcx, impl_id);
1507 let kind = match impl_item.node {
1508 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1509 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1510 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1511 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1514 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1515 .map(|node_item| node_item.map(|parent| parent.defaultness));
1517 if let Some(parent) = parent {
1518 if tcx.impl_item_is_final(&parent) {
1519 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1525 fn check_impl_items_against_trait<'tcx>(
1529 impl_trait_ref: ty::TraitRef<'tcx>,
1530 impl_item_refs: &[hir::ImplItemRef],
1532 let impl_span = tcx.sess.source_map().def_span(impl_span);
1534 // If the trait reference itself is erroneous (so the compilation is going
1535 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1536 // isn't populated for such impls.
1537 if impl_trait_ref.references_error() { return; }
1539 // Locate trait definition and items
1540 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1541 let mut overridden_associated_type = None;
1543 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1545 // Check existing impl methods to see if they are both present in trait
1546 // and compatible with trait signature
1547 for impl_item in impl_items() {
1548 let ty_impl_item = tcx.associated_item(
1549 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1550 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1551 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1552 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1554 // Not compatible, but needed for the error message
1555 tcx.associated_items(impl_trait_ref.def_id)
1556 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1559 // Check that impl definition matches trait definition
1560 if let Some(ty_trait_item) = ty_trait_item {
1561 match impl_item.node {
1562 hir::ImplItemKind::Const(..) => {
1563 // Find associated const definition.
1564 if ty_trait_item.kind == ty::AssocKind::Const {
1565 compare_const_impl(tcx,
1571 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1572 "item `{}` is an associated const, \
1573 which doesn't match its trait `{}`",
1576 err.span_label(impl_item.span, "does not match trait");
1577 // We can only get the spans from local trait definition
1578 // Same for E0324 and E0325
1579 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1580 err.span_label(trait_span, "item in trait");
1585 hir::ImplItemKind::Method(..) => {
1586 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1587 if ty_trait_item.kind == ty::AssocKind::Method {
1588 compare_impl_method(tcx,
1595 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1596 "item `{}` is an associated method, \
1597 which doesn't match its trait `{}`",
1600 err.span_label(impl_item.span, "does not match trait");
1601 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1602 err.span_label(trait_span, "item in trait");
1607 hir::ImplItemKind::Existential(..) |
1608 hir::ImplItemKind::Type(_) => {
1609 if ty_trait_item.kind == ty::AssocKind::Type {
1610 if ty_trait_item.defaultness.has_value() {
1611 overridden_associated_type = Some(impl_item);
1614 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1615 "item `{}` is an associated type, \
1616 which doesn't match its trait `{}`",
1619 err.span_label(impl_item.span, "does not match trait");
1620 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1621 err.span_label(trait_span, "item in trait");
1628 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1632 // Check for missing items from trait
1633 let mut missing_items = Vec::new();
1634 let mut invalidated_items = Vec::new();
1635 let associated_type_overridden = overridden_associated_type.is_some();
1636 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1637 let is_implemented = trait_def.ancestors(tcx, impl_id)
1638 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1640 .map(|node_item| !node_item.node.is_from_trait())
1643 if !is_implemented && !tcx.impl_is_default(impl_id) {
1644 if !trait_item.defaultness.has_value() {
1645 missing_items.push(trait_item);
1646 } else if associated_type_overridden {
1647 invalidated_items.push(trait_item.ident);
1652 if !missing_items.is_empty() {
1653 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1654 "not all trait items implemented, missing: `{}`",
1655 missing_items.iter()
1656 .map(|trait_item| trait_item.ident.to_string())
1657 .collect::<Vec<_>>().join("`, `"));
1658 err.span_label(impl_span, format!("missing `{}` in implementation",
1659 missing_items.iter()
1660 .map(|trait_item| trait_item.ident.to_string())
1661 .collect::<Vec<_>>().join("`, `")));
1662 for trait_item in missing_items {
1663 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1664 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1666 err.note_trait_signature(trait_item.ident.to_string(),
1667 trait_item.signature(tcx));
1673 if !invalidated_items.is_empty() {
1674 let invalidator = overridden_associated_type.unwrap();
1675 span_err!(tcx.sess, invalidator.span, E0399,
1676 "the following trait items need to be reimplemented \
1677 as `{}` was overridden: `{}`",
1679 invalidated_items.iter()
1680 .map(|name| name.to_string())
1681 .collect::<Vec<_>>().join("`, `"))
1685 /// Checks whether a type can be represented in memory. In particular, it
1686 /// identifies types that contain themselves without indirection through a
1687 /// pointer, which would mean their size is unbounded.
1688 fn check_representable<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, item_def_id: DefId) -> bool {
1689 let rty = tcx.type_of(item_def_id);
1691 // Check that it is possible to represent this type. This call identifies
1692 // (1) types that contain themselves and (2) types that contain a different
1693 // recursive type. It is only necessary to throw an error on those that
1694 // contain themselves. For case 2, there must be an inner type that will be
1695 // caught by case 1.
1696 match rty.is_representable(tcx, sp) {
1697 Representability::SelfRecursive(spans) => {
1698 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1700 err.span_label(span, "recursive without indirection");
1705 Representability::Representable | Representability::ContainsRecursive => (),
1710 pub fn check_simd<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1711 let t = tcx.type_of(def_id);
1712 if let ty::Adt(def, substs) = t.sty {
1713 if def.is_struct() {
1714 let fields = &def.non_enum_variant().fields;
1715 if fields.is_empty() {
1716 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1719 let e = fields[0].ty(tcx, substs);
1720 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1721 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1722 .span_label(sp, "SIMD elements must have the same type")
1727 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1728 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1730 span_err!(tcx.sess, sp, E0077,
1731 "SIMD vector element type should be machine type");
1739 fn check_packed<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1740 let repr = tcx.adt_def(def_id).repr;
1742 for attr in tcx.get_attrs(def_id).iter() {
1743 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1744 if let attr::ReprPacked(pack) = r {
1745 if pack != repr.pack {
1746 struct_span_err!(tcx.sess, sp, E0634,
1747 "type has conflicting packed representation hints").emit();
1753 struct_span_err!(tcx.sess, sp, E0587,
1754 "type has conflicting packed and align representation hints").emit();
1756 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1757 struct_span_err!(tcx.sess, sp, E0588,
1758 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1763 fn check_packed_inner<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1764 let t = tcx.type_of(def_id);
1765 if stack.contains(&def_id) {
1766 debug!("check_packed_inner: {:?} is recursive", t);
1769 if let ty::Adt(def, substs) = t.sty {
1770 if def.is_struct() || def.is_union() {
1771 if tcx.adt_def(def.did).repr.align > 0 {
1774 // push struct def_id before checking fields
1776 for field in &def.non_enum_variant().fields {
1777 let f = field.ty(tcx, substs);
1778 if let ty::Adt(def, _) = f.sty {
1779 if check_packed_inner(tcx, def.did, stack) {
1784 // only need to pop if not early out
1791 /// Emit an error when encountering more or less than one variant in a transparent enum.
1792 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1793 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1794 tcx.hir().span_if_local(variant.def_id).unwrap()
1797 "needs exactly one variant, but has {}",
1800 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1801 err.span_label(sp, &msg);
1802 if let &[ref start.., ref end] = &variant_spans[..] {
1803 for variant_span in start {
1804 err.span_label(*variant_span, "");
1806 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1811 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1813 fn bad_non_zero_sized_fields<'tcx>(
1815 adt: &'tcx ty::AdtDef,
1817 field_spans: impl Iterator<Item = Span>,
1820 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1821 let mut err = struct_span_err!(
1825 "{}transparent {} {}",
1826 if adt.is_enum() { "the variant of a " } else { "" },
1830 err.span_label(sp, &msg);
1831 for sp in field_spans {
1832 err.span_label(sp, "this field is non-zero-sized");
1837 fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, def_id: DefId) {
1838 let adt = tcx.adt_def(def_id);
1839 if !adt.repr.transparent() {
1842 let sp = tcx.sess.source_map().def_span(sp);
1845 if !tcx.features().transparent_enums {
1847 &tcx.sess.parse_sess,
1848 sym::transparent_enums,
1850 GateIssue::Language,
1851 "transparent enums are unstable",
1854 if adt.variants.len() != 1 {
1855 bad_variant_count(tcx, adt, sp, def_id);
1856 if adt.variants.is_empty() {
1857 // Don't bother checking the fields. No variants (and thus no fields) exist.
1863 if adt.is_union() && !tcx.features().transparent_unions {
1864 emit_feature_err(&tcx.sess.parse_sess,
1865 sym::transparent_unions,
1867 GateIssue::Language,
1868 "transparent unions are unstable");
1871 // For each field, figure out if it's known to be a ZST and align(1)
1872 let field_infos = adt.all_fields().map(|field| {
1873 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1874 let param_env = tcx.param_env(field.did);
1875 let layout = tcx.layout_of(param_env.and(ty));
1876 // We are currently checking the type this field came from, so it must be local
1877 let span = tcx.hir().span_if_local(field.did).unwrap();
1878 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1879 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1883 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1888 let non_zst_count = non_zst_fields.clone().count();
1889 if non_zst_count != 1 {
1890 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1892 for (span, zst, align1) in field_infos {
1898 "zero-sized field in transparent {} has alignment larger than 1",
1900 ).span_label(span, "has alignment larger than 1").emit();
1905 #[allow(trivial_numeric_casts)]
1906 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1907 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1908 let def = tcx.adt_def(def_id);
1909 def.destructor(tcx); // force the destructor to be evaluated
1912 let attributes = tcx.get_attrs(def_id);
1913 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1915 tcx.sess, attr.span, E0084,
1916 "unsupported representation for zero-variant enum")
1917 .span_label(sp, "zero-variant enum")
1922 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1923 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1924 if !tcx.features().repr128 {
1925 emit_feature_err(&tcx.sess.parse_sess,
1928 GateIssue::Language,
1929 "repr with 128-bit type is unstable");
1934 if let Some(ref e) = v.node.disr_expr {
1935 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1939 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1940 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1941 // Check for duplicate discriminant values
1942 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1943 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1944 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1945 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1946 let i_span = match variant_i.node.disr_expr {
1947 Some(ref expr) => tcx.hir().span(expr.hir_id),
1948 None => tcx.hir().span(variant_i_hir_id)
1950 let span = match v.node.disr_expr {
1951 Some(ref expr) => tcx.hir().span(expr.hir_id),
1954 struct_span_err!(tcx.sess, span, E0081,
1955 "discriminant value `{}` already exists", disr_vals[i])
1956 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1957 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1960 disr_vals.push(discr);
1963 check_representable(tcx, sp, def_id);
1964 check_transparent(tcx, sp, def_id);
1967 fn report_unexpected_variant_res<'tcx>(tcx: TyCtxt<'tcx>, res: Res, span: Span, qpath: &QPath) {
1968 span_err!(tcx.sess, span, E0533,
1969 "expected unit struct/variant or constant, found {} `{}`",
1971 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1974 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
1975 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
1979 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1980 -> &'tcx ty::GenericPredicates<'tcx>
1983 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1984 let item_id = tcx.hir().ty_param_owner(hir_id);
1985 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1986 let generics = tcx.generics_of(item_def_id);
1987 let index = generics.param_def_id_to_index[&def_id];
1988 tcx.arena.alloc(ty::GenericPredicates {
1990 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1992 ty::Predicate::Trait(ref data)
1993 if data.skip_binder().self_ty().is_param(index) => {
1994 // HACK(eddyb) should get the original `Span`.
1995 let span = tcx.def_span(def_id);
1996 Some((predicate, span))
2006 def: Option<&ty::GenericParamDef>,
2008 ) -> Option<ty::Region<'tcx>> {
2010 Some(def) => infer::EarlyBoundRegion(span, def.name),
2011 None => infer::MiscVariable(span)
2013 Some(self.next_region_var(v))
2016 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2017 if let Some(param) = param {
2018 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2023 self.next_ty_var(TypeVariableOrigin {
2024 kind: TypeVariableOriginKind::TypeInference,
2033 param: Option<&ty::GenericParamDef>,
2035 ) -> &'tcx Const<'tcx> {
2036 if let Some(param) = param {
2037 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2042 self.next_const_var(ty, ConstVariableOrigin {
2043 kind: ConstVariableOriginKind::ConstInference,
2049 fn projected_ty_from_poly_trait_ref(&self,
2052 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2055 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2057 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2061 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2064 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2065 if ty.has_escaping_bound_vars() {
2066 ty // FIXME: normalization and escaping regions
2068 self.normalize_associated_types_in(span, &ty)
2072 fn set_tainted_by_errors(&self) {
2073 self.infcx.set_tainted_by_errors()
2076 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2077 self.write_ty(hir_id, ty)
2081 /// Controls whether the arguments are tupled. This is used for the call
2084 /// Tupling means that all call-side arguments are packed into a tuple and
2085 /// passed as a single parameter. For example, if tupling is enabled, this
2088 /// fn f(x: (isize, isize))
2090 /// Can be called as:
2097 #[derive(Clone, Eq, PartialEq)]
2098 enum TupleArgumentsFlag {
2103 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2105 inh: &'a Inherited<'a, 'tcx>,
2106 param_env: ty::ParamEnv<'tcx>,
2107 body_id: hir::HirId,
2108 ) -> FnCtxt<'a, 'tcx> {
2112 err_count_on_creation: inh.tcx.sess.err_count(),
2114 ret_coercion_span: RefCell::new(None),
2116 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2117 hir::CRATE_HIR_ID)),
2118 diverges: Cell::new(Diverges::Maybe),
2119 has_errors: Cell::new(false),
2120 enclosing_breakables: RefCell::new(EnclosingBreakables {
2122 by_id: Default::default(),
2128 pub fn sess(&self) -> &Session {
2132 pub fn err_count_since_creation(&self) -> usize {
2133 self.tcx.sess.err_count() - self.err_count_on_creation
2136 /// Produces warning on the given node, if the current point in the
2137 /// function is unreachable, and there hasn't been another warning.
2138 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2139 if self.diverges.get() == Diverges::Always &&
2140 // If span arose from a desugaring of `if` then it is the condition itself,
2141 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2142 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2143 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2144 self.diverges.set(Diverges::WarnedAlways);
2146 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2148 let msg = format!("unreachable {}", kind);
2149 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2155 code: ObligationCauseCode<'tcx>)
2156 -> ObligationCause<'tcx> {
2157 ObligationCause::new(span, self.body_id, code)
2160 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2161 self.cause(span, ObligationCauseCode::MiscObligation)
2164 /// Resolves type variables in `ty` if possible. Unlike the infcx
2165 /// version (resolve_vars_if_possible), this version will
2166 /// also select obligations if it seems useful, in an effort
2167 /// to get more type information.
2168 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2169 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2171 // No Infer()? Nothing needs doing.
2172 if !ty.has_infer_types() {
2173 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2177 // If `ty` is a type variable, see whether we already know what it is.
2178 ty = self.resolve_vars_if_possible(&ty);
2179 if !ty.has_infer_types() {
2180 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2184 // If not, try resolving pending obligations as much as
2185 // possible. This can help substantially when there are
2186 // indirect dependencies that don't seem worth tracking
2188 self.select_obligations_where_possible(false);
2189 ty = self.resolve_vars_if_possible(&ty);
2191 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2195 fn record_deferred_call_resolution(
2197 closure_def_id: DefId,
2198 r: DeferredCallResolution<'tcx>,
2200 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2201 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2204 fn remove_deferred_call_resolutions(
2206 closure_def_id: DefId,
2207 ) -> Vec<DeferredCallResolution<'tcx>> {
2208 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2209 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2212 pub fn tag(&self) -> String {
2213 format!("{:p}", self)
2216 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2217 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2218 span_bug!(span, "no type for local variable {}",
2219 self.tcx.hir().node_to_string(nid))
2224 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2225 debug!("write_ty({:?}, {:?}) in fcx {}",
2226 id, self.resolve_vars_if_possible(&ty), self.tag());
2227 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2229 if ty.references_error() {
2230 self.has_errors.set(true);
2231 self.set_tainted_by_errors();
2235 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2236 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2239 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2240 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2243 pub fn write_method_call(&self,
2245 method: MethodCallee<'tcx>) {
2246 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2247 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2248 self.write_substs(hir_id, method.substs);
2250 // When the method is confirmed, the `method.substs` includes
2251 // parameters from not just the method, but also the impl of
2252 // the method -- in particular, the `Self` type will be fully
2253 // resolved. However, those are not something that the "user
2254 // specified" -- i.e., those types come from the inferred type
2255 // of the receiver, not something the user wrote. So when we
2256 // create the user-substs, we want to replace those earlier
2257 // types with just the types that the user actually wrote --
2258 // that is, those that appear on the *method itself*.
2260 // As an example, if the user wrote something like
2261 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2262 // type of `foo` (possibly adjusted), but we don't want to
2263 // include that. We want just the `[_, u32]` part.
2264 if !method.substs.is_noop() {
2265 let method_generics = self.tcx.generics_of(method.def_id);
2266 if !method_generics.params.is_empty() {
2267 let user_type_annotation = self.infcx.probe(|_| {
2268 let user_substs = UserSubsts {
2269 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2270 let i = param.index as usize;
2271 if i < method_generics.parent_count {
2272 self.infcx.var_for_def(DUMMY_SP, param)
2277 user_self_ty: None, // not relevant here
2280 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2286 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2287 self.write_user_type_annotation(hir_id, user_type_annotation);
2292 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2293 if !substs.is_noop() {
2294 debug!("write_substs({:?}, {:?}) in fcx {}",
2299 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2303 /// Given the substs that we just converted from the HIR, try to
2304 /// canonicalize them and store them as user-given substitutions
2305 /// (i.e., substitutions that must be respected by the NLL check).
2307 /// This should be invoked **before any unifications have
2308 /// occurred**, so that annotations like `Vec<_>` are preserved
2310 pub fn write_user_type_annotation_from_substs(
2314 substs: SubstsRef<'tcx>,
2315 user_self_ty: Option<UserSelfTy<'tcx>>,
2318 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2319 user_self_ty={:?} in fcx {}",
2320 hir_id, def_id, substs, user_self_ty, self.tag(),
2323 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2324 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2325 &UserType::TypeOf(def_id, UserSubsts {
2330 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2331 self.write_user_type_annotation(hir_id, canonicalized);
2335 pub fn write_user_type_annotation(
2338 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2341 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2342 hir_id, canonical_user_type_annotation, self.tag(),
2345 if !canonical_user_type_annotation.is_identity() {
2346 self.tables.borrow_mut().user_provided_types_mut().insert(
2347 hir_id, canonical_user_type_annotation
2350 debug!("write_user_type_annotation: skipping identity substs");
2354 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2355 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2361 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2362 Entry::Vacant(entry) => { entry.insert(adj); },
2363 Entry::Occupied(mut entry) => {
2364 debug!(" - composing on top of {:?}", entry.get());
2365 match (&entry.get()[..], &adj[..]) {
2366 // Applying any adjustment on top of a NeverToAny
2367 // is a valid NeverToAny adjustment, because it can't
2369 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2371 Adjustment { kind: Adjust::Deref(_), .. },
2372 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2374 Adjustment { kind: Adjust::Deref(_), .. },
2375 .. // Any following adjustments are allowed.
2377 // A reborrow has no effect before a dereference.
2379 // FIXME: currently we never try to compose autoderefs
2380 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2382 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2383 expr, entry.get(), adj)
2385 *entry.get_mut() = adj;
2390 /// Basically whenever we are converting from a type scheme into
2391 /// the fn body space, we always want to normalize associated
2392 /// types as well. This function combines the two.
2393 fn instantiate_type_scheme<T>(&self,
2395 substs: SubstsRef<'tcx>,
2398 where T : TypeFoldable<'tcx>
2400 let value = value.subst(self.tcx, substs);
2401 let result = self.normalize_associated_types_in(span, &value);
2402 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2409 /// As `instantiate_type_scheme`, but for the bounds found in a
2410 /// generic type scheme.
2411 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2412 -> ty::InstantiatedPredicates<'tcx> {
2413 let bounds = self.tcx.predicates_of(def_id);
2414 let result = bounds.instantiate(self.tcx, substs);
2415 let result = self.normalize_associated_types_in(span, &result);
2416 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2423 /// Replaces the opaque types from the given value with type variables,
2424 /// and records the `OpaqueTypeMap` for later use during writeback. See
2425 /// `InferCtxt::instantiate_opaque_types` for more details.
2426 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2428 parent_id: hir::HirId,
2431 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2432 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2436 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2437 self.instantiate_opaque_types(
2445 let mut opaque_types = self.opaque_types.borrow_mut();
2446 for (ty, decl) in opaque_type_map {
2447 let old_value = opaque_types.insert(ty, decl);
2448 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2454 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2455 where T : TypeFoldable<'tcx>
2457 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2460 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2462 where T : TypeFoldable<'tcx>
2464 self.inh.partially_normalize_associated_types_in(span,
2470 pub fn require_type_meets(&self,
2473 code: traits::ObligationCauseCode<'tcx>,
2476 self.register_bound(
2479 traits::ObligationCause::new(span, self.body_id, code));
2482 pub fn require_type_is_sized(&self,
2485 code: traits::ObligationCauseCode<'tcx>)
2487 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2488 self.require_type_meets(ty, span, code, lang_item);
2491 pub fn require_type_is_sized_deferred(&self,
2494 code: traits::ObligationCauseCode<'tcx>)
2496 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2499 pub fn register_bound(&self,
2502 cause: traits::ObligationCause<'tcx>)
2504 self.fulfillment_cx.borrow_mut()
2505 .register_bound(self, self.param_env, ty, def_id, cause);
2508 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2509 let t = AstConv::ast_ty_to_ty(self, ast_t);
2510 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2514 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2515 let ty = self.to_ty(ast_ty);
2516 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2518 if Self::can_contain_user_lifetime_bounds(ty) {
2519 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2520 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2521 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2527 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2528 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2529 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2532 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2533 AstConv::ast_const_to_const(self, ast_c, ty)
2536 // If the type given by the user has free regions, save it for later, since
2537 // NLL would like to enforce those. Also pass in types that involve
2538 // projections, since those can resolve to `'static` bounds (modulo #54940,
2539 // which hopefully will be fixed by the time you see this comment, dear
2540 // reader, although I have my doubts). Also pass in types with inference
2541 // types, because they may be repeated. Other sorts of things are already
2542 // sufficiently enforced with erased regions. =)
2543 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2545 T: TypeFoldable<'tcx>
2547 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2550 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2551 match self.tables.borrow().node_types().get(id) {
2553 None if self.is_tainted_by_errors() => self.tcx.types.err,
2555 bug!("no type for node {}: {} in fcx {}",
2556 id, self.tcx.hir().node_to_string(id),
2562 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2563 /// outlive the region `r`.
2564 pub fn register_wf_obligation(&self,
2567 code: traits::ObligationCauseCode<'tcx>)
2569 // WF obligations never themselves fail, so no real need to give a detailed cause:
2570 let cause = traits::ObligationCause::new(span, self.body_id, code);
2571 self.register_predicate(traits::Obligation::new(cause,
2573 ty::Predicate::WellFormed(ty)));
2576 /// Registers obligations that all types appearing in `substs` are well-formed.
2577 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2578 for ty in substs.types() {
2579 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2583 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2584 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2585 /// trait/region obligations.
2587 /// For example, if there is a function:
2590 /// fn foo<'a,T:'a>(...)
2593 /// and a reference:
2599 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2600 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2601 pub fn add_obligations_for_parameters(&self,
2602 cause: traits::ObligationCause<'tcx>,
2603 predicates: &ty::InstantiatedPredicates<'tcx>)
2605 assert!(!predicates.has_escaping_bound_vars());
2607 debug!("add_obligations_for_parameters(predicates={:?})",
2610 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2611 self.register_predicate(obligation);
2615 // FIXME(arielb1): use this instead of field.ty everywhere
2616 // Only for fields! Returns <none> for methods>
2617 // Indifferent to privacy flags
2618 pub fn field_ty(&self,
2620 field: &'tcx ty::FieldDef,
2621 substs: SubstsRef<'tcx>)
2624 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2627 fn check_casts(&self) {
2628 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2629 for cast in deferred_cast_checks.drain(..) {
2634 fn resolve_generator_interiors(&self, def_id: DefId) {
2635 let mut generators = self.deferred_generator_interiors.borrow_mut();
2636 for (body_id, interior) in generators.drain(..) {
2637 self.select_obligations_where_possible(false);
2638 generator_interior::resolve_interior(self, def_id, body_id, interior);
2642 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2643 // Non-numerics get replaced with ! or () (depending on whether
2644 // feature(never_type) is enabled, unconstrained ints with i32,
2645 // unconstrained floats with f64.
2646 // Fallback becomes very dubious if we have encountered type-checking errors.
2647 // In that case, fallback to Error.
2648 // The return value indicates whether fallback has occurred.
2649 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2650 use rustc::ty::error::UnconstrainedNumeric::Neither;
2651 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2653 assert!(ty.is_ty_infer());
2654 let fallback = match self.type_is_unconstrained_numeric(ty) {
2655 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2656 UnconstrainedInt => self.tcx.types.i32,
2657 UnconstrainedFloat => self.tcx.types.f64,
2658 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2659 Neither => return false,
2661 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2662 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2666 fn select_all_obligations_or_error(&self) {
2667 debug!("select_all_obligations_or_error");
2668 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2669 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2673 /// Select as many obligations as we can at present.
2674 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2675 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2676 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2680 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2681 /// returns a type of `&T`, but the actual type we assign to the
2682 /// *expression* is `T`. So this function just peels off the return
2683 /// type by one layer to yield `T`.
2684 fn make_overloaded_place_return_type(&self,
2685 method: MethodCallee<'tcx>)
2686 -> ty::TypeAndMut<'tcx>
2688 // extract method return type, which will be &T;
2689 let ret_ty = method.sig.output();
2691 // method returns &T, but the type as visible to user is T, so deref
2692 ret_ty.builtin_deref(true).unwrap()
2698 base_expr: &'tcx hir::Expr,
2702 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2703 // FIXME(#18741) -- this is almost but not quite the same as the
2704 // autoderef that normal method probing does. They could likely be
2707 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2708 let mut result = None;
2709 while result.is_none() && autoderef.next().is_some() {
2710 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2712 autoderef.finalize(self);
2716 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2717 /// (and otherwise adjust) `base_expr`, looking for a type which either
2718 /// supports builtin indexing or overloaded indexing.
2719 /// This loop implements one step in that search; the autoderef loop
2720 /// is implemented by `lookup_indexing`.
2724 base_expr: &hir::Expr,
2725 autoderef: &Autoderef<'a, 'tcx>,
2728 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2729 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2730 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2737 for &unsize in &[false, true] {
2738 let mut self_ty = adjusted_ty;
2740 // We only unsize arrays here.
2741 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2742 self_ty = self.tcx.mk_slice(element_ty);
2748 // If some lookup succeeds, write callee into table and extract index/element
2749 // type from the method signature.
2750 // If some lookup succeeded, install method in table
2751 let input_ty = self.next_ty_var(TypeVariableOrigin {
2752 kind: TypeVariableOriginKind::AutoDeref,
2753 span: base_expr.span,
2755 let method = self.try_overloaded_place_op(
2756 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2758 let result = method.map(|ok| {
2759 debug!("try_index_step: success, using overloaded indexing");
2760 let method = self.register_infer_ok_obligations(ok);
2762 let mut adjustments = autoderef.adjust_steps(self, needs);
2763 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2764 let mutbl = match r_mutbl {
2765 hir::MutImmutable => AutoBorrowMutability::Immutable,
2766 hir::MutMutable => AutoBorrowMutability::Mutable {
2767 // Indexing can be desugared to a method call,
2768 // so maybe we could use two-phase here.
2769 // See the documentation of AllowTwoPhase for why that's
2770 // not the case today.
2771 allow_two_phase_borrow: AllowTwoPhase::No,
2774 adjustments.push(Adjustment {
2775 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2776 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2783 adjustments.push(Adjustment {
2784 kind: Adjust::Pointer(PointerCast::Unsize),
2785 target: method.sig.inputs()[0]
2788 self.apply_adjustments(base_expr, adjustments);
2790 self.write_method_call(expr.hir_id, method);
2791 (input_ty, self.make_overloaded_place_return_type(method).ty)
2793 if result.is_some() {
2801 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2802 let (tr, name) = match (op, is_mut) {
2803 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2804 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2805 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2806 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2808 (tr, ast::Ident::with_empty_ctxt(name))
2811 fn try_overloaded_place_op(&self,
2814 arg_tys: &[Ty<'tcx>],
2817 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2819 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2825 // Try Mut first, if needed.
2826 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2827 let method = match (needs, mut_tr) {
2828 (Needs::MutPlace, Some(trait_did)) => {
2829 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2834 // Otherwise, fall back to the immutable version.
2835 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2836 let method = match (method, imm_tr) {
2837 (None, Some(trait_did)) => {
2838 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2840 (method, _) => method,
2846 fn check_method_argument_types(
2850 method: Result<MethodCallee<'tcx>, ()>,
2851 args_no_rcvr: &'tcx [hir::Expr],
2852 tuple_arguments: TupleArgumentsFlag,
2853 expected: Expectation<'tcx>,
2855 let has_error = match method {
2857 method.substs.references_error() || method.sig.references_error()
2862 let err_inputs = self.err_args(args_no_rcvr.len());
2864 let err_inputs = match tuple_arguments {
2865 DontTupleArguments => err_inputs,
2866 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2869 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2870 false, tuple_arguments, None);
2871 return self.tcx.types.err;
2874 let method = method.unwrap();
2875 // HACK(eddyb) ignore self in the definition (see above).
2876 let expected_arg_tys = self.expected_inputs_for_expected_output(
2879 method.sig.output(),
2880 &method.sig.inputs()[1..]
2882 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2883 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2884 self.tcx.hir().span_if_local(method.def_id));
2888 fn self_type_matches_expected_vid(
2890 trait_ref: ty::PolyTraitRef<'tcx>,
2891 expected_vid: ty::TyVid,
2893 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2895 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2896 trait_ref, self_ty, expected_vid
2899 ty::Infer(ty::TyVar(found_vid)) => {
2900 // FIXME: consider using `sub_root_var` here so we
2901 // can see through subtyping.
2902 let found_vid = self.root_var(found_vid);
2903 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2904 expected_vid == found_vid
2910 fn obligations_for_self_ty<'b>(
2913 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2916 // FIXME: consider using `sub_root_var` here so we
2917 // can see through subtyping.
2918 let ty_var_root = self.root_var(self_ty);
2919 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2920 self_ty, ty_var_root,
2921 self.fulfillment_cx.borrow().pending_obligations());
2925 .pending_obligations()
2927 .filter_map(move |obligation| match obligation.predicate {
2928 ty::Predicate::Projection(ref data) =>
2929 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2930 ty::Predicate::Trait(ref data) =>
2931 Some((data.to_poly_trait_ref(), obligation)),
2932 ty::Predicate::Subtype(..) => None,
2933 ty::Predicate::RegionOutlives(..) => None,
2934 ty::Predicate::TypeOutlives(..) => None,
2935 ty::Predicate::WellFormed(..) => None,
2936 ty::Predicate::ObjectSafe(..) => None,
2937 ty::Predicate::ConstEvaluatable(..) => None,
2938 // N.B., this predicate is created by breaking down a
2939 // `ClosureType: FnFoo()` predicate, where
2940 // `ClosureType` represents some `Closure`. It can't
2941 // possibly be referring to the current closure,
2942 // because we haven't produced the `Closure` for
2943 // this closure yet; this is exactly why the other
2944 // code is looking for a self type of a unresolved
2945 // inference variable.
2946 ty::Predicate::ClosureKind(..) => None,
2947 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2950 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2951 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2952 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2956 /// Generic function that factors out common logic from function calls,
2957 /// method calls and overloaded operators.
2958 fn check_argument_types(
2962 fn_inputs: &[Ty<'tcx>],
2963 expected_arg_tys: &[Ty<'tcx>],
2964 args: &'tcx [hir::Expr],
2966 tuple_arguments: TupleArgumentsFlag,
2967 def_span: Option<Span>,
2971 // Grab the argument types, supplying fresh type variables
2972 // if the wrong number of arguments were supplied
2973 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2979 // All the input types from the fn signature must outlive the call
2980 // so as to validate implied bounds.
2981 for &fn_input_ty in fn_inputs {
2982 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2985 let expected_arg_count = fn_inputs.len();
2987 let param_count_error = |expected_count: usize,
2992 let mut err = tcx.sess.struct_span_err_with_code(sp,
2993 &format!("this function takes {}{} but {} {} supplied",
2994 if c_variadic { "at least " } else { "" },
2995 potentially_plural_count(expected_count, "parameter"),
2996 potentially_plural_count(arg_count, "parameter"),
2997 if arg_count == 1 {"was"} else {"were"}),
2998 DiagnosticId::Error(error_code.to_owned()));
3000 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3001 err.span_label(def_s, "defined here");
3004 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3005 // remove closing `)` from the span
3006 let sugg_span = sugg_span.shrink_to_lo();
3007 err.span_suggestion(
3009 "expected the unit value `()`; create it with empty parentheses",
3011 Applicability::MachineApplicable);
3013 err.span_label(sp, format!("expected {}{}",
3014 if c_variadic { "at least " } else { "" },
3015 potentially_plural_count(expected_count, "parameter")));
3020 let mut expected_arg_tys = expected_arg_tys.to_vec();
3022 let formal_tys = if tuple_arguments == TupleArguments {
3023 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3024 match tuple_type.sty {
3025 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3026 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3027 expected_arg_tys = vec![];
3028 self.err_args(args.len())
3030 ty::Tuple(arg_types) => {
3031 expected_arg_tys = match expected_arg_tys.get(0) {
3032 Some(&ty) => match ty.sty {
3033 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3038 arg_types.iter().map(|k| k.expect_ty()).collect()
3041 span_err!(tcx.sess, sp, E0059,
3042 "cannot use call notation; the first type parameter \
3043 for the function trait is neither a tuple nor unit");
3044 expected_arg_tys = vec![];
3045 self.err_args(args.len())
3048 } else if expected_arg_count == supplied_arg_count {
3050 } else if c_variadic {
3051 if supplied_arg_count >= expected_arg_count {
3054 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3055 expected_arg_tys = vec![];
3056 self.err_args(supplied_arg_count)
3059 // is the missing argument of type `()`?
3060 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3061 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3062 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3063 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3067 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3069 expected_arg_tys = vec![];
3070 self.err_args(supplied_arg_count)
3073 debug!("check_argument_types: formal_tys={:?}",
3074 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3076 // If there is no expectation, expect formal_tys.
3077 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3083 // Check the arguments.
3084 // We do this in a pretty awful way: first we type-check any arguments
3085 // that are not closures, then we type-check the closures. This is so
3086 // that we have more information about the types of arguments when we
3087 // type-check the functions. This isn't really the right way to do this.
3088 for &check_closures in &[false, true] {
3089 debug!("check_closures={}", check_closures);
3091 // More awful hacks: before we check argument types, try to do
3092 // an "opportunistic" vtable resolution of any trait bounds on
3093 // the call. This helps coercions.
3095 self.select_obligations_where_possible(false);
3098 // For C-variadic functions, we don't have a declared type for all of
3099 // the arguments hence we only do our usual type checking with
3100 // the arguments who's types we do know.
3101 let t = if c_variadic {
3103 } else if tuple_arguments == TupleArguments {
3108 for (i, arg) in args.iter().take(t).enumerate() {
3109 // Warn only for the first loop (the "no closures" one).
3110 // Closure arguments themselves can't be diverging, but
3111 // a previous argument can, e.g., `foo(panic!(), || {})`.
3112 if !check_closures {
3113 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3116 let is_closure = match arg.node {
3117 ExprKind::Closure(..) => true,
3121 if is_closure != check_closures {
3125 debug!("checking the argument");
3126 let formal_ty = formal_tys[i];
3128 // The special-cased logic below has three functions:
3129 // 1. Provide as good of an expected type as possible.
3130 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3132 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3134 // 2. Coerce to the most detailed type that could be coerced
3135 // to, which is `expected_ty` if `rvalue_hint` returns an
3136 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3137 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3138 // We're processing function arguments so we definitely want to use
3139 // two-phase borrows.
3140 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3142 // 3. Relate the expected type and the formal one,
3143 // if the expected type was used for the coercion.
3144 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3148 // We also need to make sure we at least write the ty of the other
3149 // arguments which we skipped above.
3151 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3152 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3153 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3156 for arg in args.iter().skip(expected_arg_count) {
3157 let arg_ty = self.check_expr(&arg);
3159 // There are a few types which get autopromoted when passed via varargs
3160 // in C but we just error out instead and require explicit casts.
3161 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3163 ty::Float(ast::FloatTy::F32) => {
3164 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3166 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3167 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3169 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3170 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3173 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3174 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3175 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3183 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3184 vec![self.tcx.types.err; len]
3187 // AST fragment checking
3190 expected: Expectation<'tcx>)
3196 ast::LitKind::Str(..) => tcx.mk_static_str(),
3197 ast::LitKind::ByteStr(ref v) => {
3198 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3199 tcx.mk_array(tcx.types.u8, v.len() as u64))
3201 ast::LitKind::Byte(_) => tcx.types.u8,
3202 ast::LitKind::Char(_) => tcx.types.char,
3203 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3204 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3205 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3206 let opt_ty = expected.to_option(self).and_then(|ty| {
3208 ty::Int(_) | ty::Uint(_) => Some(ty),
3209 ty::Char => Some(tcx.types.u8),
3210 ty::RawPtr(..) => Some(tcx.types.usize),
3211 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3215 opt_ty.unwrap_or_else(|| self.next_int_var())
3217 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3218 ast::LitKind::FloatUnsuffixed(_) => {
3219 let opt_ty = expected.to_option(self).and_then(|ty| {
3221 ty::Float(_) => Some(ty),
3225 opt_ty.unwrap_or_else(|| self.next_float_var())
3227 ast::LitKind::Bool(_) => tcx.types.bool,
3228 ast::LitKind::Err(_) => tcx.types.err,
3232 // Determine the `Self` type, using fresh variables for all variables
3233 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3234 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3236 pub fn impl_self_ty(&self,
3237 span: Span, // (potential) receiver for this impl
3239 -> TypeAndSubsts<'tcx> {
3240 let ity = self.tcx.type_of(did);
3241 debug!("impl_self_ty: ity={:?}", ity);
3243 let substs = self.fresh_substs_for_item(span, did);
3244 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3246 TypeAndSubsts { substs: substs, ty: substd_ty }
3249 /// Unifies the output type with the expected type early, for more coercions
3250 /// and forward type information on the input expressions.
3251 fn expected_inputs_for_expected_output(&self,
3253 expected_ret: Expectation<'tcx>,
3254 formal_ret: Ty<'tcx>,
3255 formal_args: &[Ty<'tcx>])
3257 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3258 let ret_ty = match expected_ret.only_has_type(self) {
3260 None => return Vec::new()
3262 let expect_args = self.fudge_inference_if_ok(|| {
3263 // Attempt to apply a subtyping relationship between the formal
3264 // return type (likely containing type variables if the function
3265 // is polymorphic) and the expected return type.
3266 // No argument expectations are produced if unification fails.
3267 let origin = self.misc(call_span);
3268 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3270 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3271 // to identity so the resulting type is not constrained.
3274 // Process any obligations locally as much as
3275 // we can. We don't care if some things turn
3276 // out unconstrained or ambiguous, as we're
3277 // just trying to get hints here.
3278 self.save_and_restore_in_snapshot_flag(|_| {
3279 let mut fulfill = TraitEngine::new(self.tcx);
3280 for obligation in ok.obligations {
3281 fulfill.register_predicate_obligation(self, obligation);
3283 fulfill.select_where_possible(self)
3284 }).map_err(|_| ())?;
3286 Err(_) => return Err(()),
3289 // Record all the argument types, with the substitutions
3290 // produced from the above subtyping unification.
3291 Ok(formal_args.iter().map(|ty| {
3292 self.resolve_vars_if_possible(ty)
3294 }).unwrap_or_default();
3295 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3296 formal_args, formal_ret,
3297 expect_args, expected_ret);
3301 pub fn check_struct_path(&self,
3304 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3305 let path_span = match *qpath {
3306 QPath::Resolved(_, ref path) => path.span,
3307 QPath::TypeRelative(ref qself, _) => qself.span
3309 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3310 let variant = match def {
3312 self.set_tainted_by_errors();
3315 Res::Def(DefKind::Variant, _) => {
3317 ty::Adt(adt, substs) => {
3318 Some((adt.variant_of_res(def), adt.did, substs))
3320 _ => bug!("unexpected type: {:?}", ty)
3323 Res::Def(DefKind::Struct, _)
3324 | Res::Def(DefKind::Union, _)
3325 | Res::Def(DefKind::TyAlias, _)
3326 | Res::Def(DefKind::AssocTy, _)
3327 | Res::SelfTy(..) => {
3329 ty::Adt(adt, substs) if !adt.is_enum() => {
3330 Some((adt.non_enum_variant(), adt.did, substs))
3335 _ => bug!("unexpected definition: {:?}", def)
3338 if let Some((variant, did, substs)) = variant {
3339 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3340 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3342 // Check bounds on type arguments used in the path.
3343 let bounds = self.instantiate_bounds(path_span, did, substs);
3344 let cause = traits::ObligationCause::new(path_span, self.body_id,
3345 traits::ItemObligation(did));
3346 self.add_obligations_for_parameters(cause, &bounds);
3350 struct_span_err!(self.tcx.sess, path_span, E0071,
3351 "expected struct, variant or union type, found {}",
3352 ty.sort_string(self.tcx))
3353 .span_label(path_span, "not a struct")
3359 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3360 // The newly resolved definition is written into `type_dependent_defs`.
3361 fn finish_resolving_struct_path(&self,
3368 QPath::Resolved(ref maybe_qself, ref path) => {
3369 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3370 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3373 QPath::TypeRelative(ref qself, ref segment) => {
3374 let ty = self.to_ty(qself);
3376 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3381 let result = AstConv::associated_path_to_ty(
3390 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3391 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3393 // Write back the new resolution.
3394 self.write_resolution(hir_id, result);
3396 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3401 /// Resolves an associated value path into a base type and associated constant, or method
3402 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3403 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3407 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3409 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3410 let (ty, qself, item_segment) = match *qpath {
3411 QPath::Resolved(ref opt_qself, ref path) => {
3413 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3414 &path.segments[..]);
3416 QPath::TypeRelative(ref qself, ref segment) => {
3417 (self.to_ty(qself), qself, segment)
3420 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3421 // Return directly on cache hit. This is useful to avoid doubly reporting
3422 // errors with default match binding modes. See #44614.
3423 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3424 .unwrap_or(Res::Err);
3425 return (def, Some(ty), slice::from_ref(&**item_segment));
3427 let item_name = item_segment.ident;
3428 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3429 let result = match error {
3430 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3431 _ => Err(ErrorReported),
3433 if item_name.name != kw::Invalid {
3434 self.report_method_error(
3438 SelfSource::QPath(qself),
3446 // Write back the new resolution.
3447 self.write_resolution(hir_id, result);
3449 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3451 slice::from_ref(&**item_segment),
3455 pub fn check_decl_initializer(
3457 local: &'tcx hir::Local,
3458 init: &'tcx hir::Expr,
3460 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3461 // for #42640 (default match binding modes).
3464 let ref_bindings = local.pat.contains_explicit_ref_binding();
3466 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3467 if let Some(m) = ref_bindings {
3468 // Somewhat subtle: if we have a `ref` binding in the pattern,
3469 // we want to avoid introducing coercions for the RHS. This is
3470 // both because it helps preserve sanity and, in the case of
3471 // ref mut, for soundness (issue #23116). In particular, in
3472 // the latter case, we need to be clear that the type of the
3473 // referent for the reference that results is *equal to* the
3474 // type of the place it is referencing, and not some
3475 // supertype thereof.
3476 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3477 self.demand_eqtype(init.span, local_ty, init_ty);
3480 self.check_expr_coercable_to_type(init, local_ty)
3484 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3485 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3486 self.write_ty(local.hir_id, t);
3488 if let Some(ref init) = local.init {
3489 let init_ty = self.check_decl_initializer(local, &init);
3490 if init_ty.references_error() {
3491 self.write_ty(local.hir_id, init_ty);
3495 self.check_pat_walk(
3498 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3501 let pat_ty = self.node_ty(local.pat.hir_id);
3502 if pat_ty.references_error() {
3503 self.write_ty(local.hir_id, pat_ty);
3507 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3508 // Don't do all the complex logic below for `DeclItem`.
3510 hir::StmtKind::Item(..) => return,
3511 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3514 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3516 // Hide the outer diverging and `has_errors` flags.
3517 let old_diverges = self.diverges.get();
3518 let old_has_errors = self.has_errors.get();
3519 self.diverges.set(Diverges::Maybe);
3520 self.has_errors.set(false);
3523 hir::StmtKind::Local(ref l) => {
3524 self.check_decl_local(&l);
3527 hir::StmtKind::Item(_) => {}
3528 hir::StmtKind::Expr(ref expr) => {
3529 // Check with expected type of `()`.
3530 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3532 hir::StmtKind::Semi(ref expr) => {
3533 self.check_expr(&expr);
3537 // Combine the diverging and `has_error` flags.
3538 self.diverges.set(self.diverges.get() | old_diverges);
3539 self.has_errors.set(self.has_errors.get() | old_has_errors);
3542 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3543 let unit = self.tcx.mk_unit();
3544 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3546 // if the block produces a `!` value, that can always be
3547 // (effectively) coerced to unit.
3549 self.demand_suptype(blk.span, unit, ty);
3553 fn check_block_with_expected(
3555 blk: &'tcx hir::Block,
3556 expected: Expectation<'tcx>,
3559 let mut fcx_ps = self.ps.borrow_mut();
3560 let unsafety_state = fcx_ps.recurse(blk);
3561 replace(&mut *fcx_ps, unsafety_state)
3564 // In some cases, blocks have just one exit, but other blocks
3565 // can be targeted by multiple breaks. This can happen both
3566 // with labeled blocks as well as when we desugar
3567 // a `try { ... }` expression.
3571 // 'a: { if true { break 'a Err(()); } Ok(()) }
3573 // Here we would wind up with two coercions, one from
3574 // `Err(())` and the other from the tail expression
3575 // `Ok(())`. If the tail expression is omitted, that's a
3576 // "forced unit" -- unless the block diverges, in which
3577 // case we can ignore the tail expression (e.g., `'a: {
3578 // break 'a 22; }` would not force the type of the block
3580 let tail_expr = blk.expr.as_ref();
3581 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3582 let coerce = if blk.targeted_by_break {
3583 CoerceMany::new(coerce_to_ty)
3585 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3586 Some(e) => slice::from_ref(e),
3589 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3592 let prev_diverges = self.diverges.get();
3593 let ctxt = BreakableCtxt {
3594 coerce: Some(coerce),
3598 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3599 for s in &blk.stmts {
3603 // check the tail expression **without** holding the
3604 // `enclosing_breakables` lock below.
3605 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3607 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3608 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3609 let coerce = ctxt.coerce.as_mut().unwrap();
3610 if let Some(tail_expr_ty) = tail_expr_ty {
3611 let tail_expr = tail_expr.unwrap();
3612 let cause = self.cause(tail_expr.span,
3613 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3619 // Subtle: if there is no explicit tail expression,
3620 // that is typically equivalent to a tail expression
3621 // of `()` -- except if the block diverges. In that
3622 // case, there is no value supplied from the tail
3623 // expression (assuming there are no other breaks,
3624 // this implies that the type of the block will be
3627 // #41425 -- label the implicit `()` as being the
3628 // "found type" here, rather than the "expected type".
3629 if !self.diverges.get().always() {
3630 // #50009 -- Do not point at the entire fn block span, point at the return type
3631 // span, as it is the cause of the requirement, and
3632 // `consider_hint_about_removing_semicolon` will point at the last expression
3633 // if it were a relevant part of the error. This improves usability in editors
3634 // that highlight errors inline.
3635 let mut sp = blk.span;
3636 let mut fn_span = None;
3637 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3638 let ret_sp = decl.output.span();
3639 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3640 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3641 // output would otherwise be incorrect and even misleading. Make sure
3642 // the span we're aiming at correspond to a `fn` body.
3643 if block_sp == blk.span {
3645 fn_span = Some(ident.span);
3649 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3650 if let Some(expected_ty) = expected.only_has_type(self) {
3651 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3653 if let Some(fn_span) = fn_span {
3654 err.span_label(fn_span, "this function's body doesn't return");
3662 // If we can break from the block, then the block's exit is always reachable
3663 // (... as long as the entry is reachable) - regardless of the tail of the block.
3664 self.diverges.set(prev_diverges);
3667 let mut ty = ctxt.coerce.unwrap().complete(self);
3669 if self.has_errors.get() || ty.references_error() {
3670 ty = self.tcx.types.err
3673 self.write_ty(blk.hir_id, ty);
3675 *self.ps.borrow_mut() = prev;
3679 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3680 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
3682 Node::Item(&hir::Item {
3683 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3685 Node::ImplItem(&hir::ImplItem {
3686 node: hir::ImplItemKind::Method(_, body_id), ..
3688 let body = self.tcx.hir().body(body_id);
3689 if let ExprKind::Block(block, _) = &body.value.node {
3690 return Some(block.span);
3698 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3699 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
3700 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
3701 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3704 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3705 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
3707 Node::Item(&hir::Item {
3708 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3709 }) => decl.clone().and_then(|decl| {
3710 // This is less than ideal, it will not suggest a return type span on any
3711 // method called `main`, regardless of whether it is actually the entry point,
3712 // but it will still present it as the reason for the expected type.
3713 Some((decl, ident, ident.name != sym::main))
3715 Node::TraitItem(&hir::TraitItem {
3716 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3719 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
3720 Node::ImplItem(&hir::ImplItem {
3721 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3724 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
3729 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3730 /// suggestion can be made, `None` otherwise.
3731 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
3732 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3733 // `while` before reaching it, as block tail returns are not available in them.
3734 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3735 let parent = self.tcx.hir().get_by_hir_id(blk_id);
3736 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3740 /// On implicit return expressions with mismatched types, provides the following suggestions:
3742 /// - Points out the method's return type as the reason for the expected type.
3743 /// - Possible missing semicolon.
3744 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3745 pub fn suggest_mismatched_types_on_tail(
3747 err: &mut DiagnosticBuilder<'tcx>,
3748 expression: &'tcx hir::Expr,
3754 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3755 let mut pointing_at_return_type = false;
3756 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3757 pointing_at_return_type = self.suggest_missing_return_type(
3758 err, &fn_decl, expected, found, can_suggest);
3760 self.suggest_ref_or_into(err, expression, expected, found);
3761 pointing_at_return_type
3764 pub fn suggest_ref_or_into(
3766 err: &mut DiagnosticBuilder<'tcx>,
3771 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3772 err.span_suggestion(
3776 Applicability::MachineApplicable,
3778 } else if !self.check_for_cast(err, expr, found, expected) {
3779 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3783 let methods = self.get_conversion_methods(expr.span, expected, found);
3784 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3785 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3786 .filter_map(|(receiver, method)| {
3787 let method_call = format!(".{}()", method.ident);
3788 if receiver.ends_with(&method_call) {
3789 None // do not suggest code that is already there (#53348)
3791 let method_call_list = [".to_vec()", ".to_string()"];
3792 let sugg = if receiver.ends_with(".clone()")
3793 && method_call_list.contains(&method_call.as_str()) {
3794 let max_len = receiver.rfind(".").unwrap();
3795 format!("{}{}", &receiver[..max_len], method_call)
3797 format!("{}{}", receiver, method_call)
3799 Some(if is_struct_pat_shorthand_field {
3800 format!("{}: {}", receiver, sugg)
3806 if suggestions.peek().is_some() {
3807 err.span_suggestions(
3809 "try using a conversion method",
3811 Applicability::MaybeIncorrect,
3818 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3822 /// bar_that_returns_u32()
3826 /// This routine checks if the return expression in a block would make sense on its own as a
3827 /// statement and the return type has been left as default or has been specified as `()`. If so,
3828 /// it suggests adding a semicolon.
3829 fn suggest_missing_semicolon(
3831 err: &mut DiagnosticBuilder<'tcx>,
3832 expression: &'tcx hir::Expr,
3836 if expected.is_unit() {
3837 // `BlockTailExpression` only relevant if the tail expr would be
3838 // useful on its own.
3839 match expression.node {
3840 ExprKind::Call(..) |
3841 ExprKind::MethodCall(..) |
3842 ExprKind::While(..) |
3843 ExprKind::Loop(..) |
3844 ExprKind::Match(..) |
3845 ExprKind::Block(..) => {
3846 let sp = self.tcx.sess.source_map().next_point(cause_span);
3847 err.span_suggestion(
3849 "try adding a semicolon",
3851 Applicability::MachineApplicable);
3858 /// A possible error is to forget to add a return type that is needed:
3862 /// bar_that_returns_u32()
3866 /// This routine checks if the return type is left as default, the method is not part of an
3867 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3869 fn suggest_missing_return_type(
3871 err: &mut DiagnosticBuilder<'tcx>,
3872 fn_decl: &hir::FnDecl,
3877 // Only suggest changing the return type for methods that
3878 // haven't set a return type at all (and aren't `fn main()` or an impl).
3879 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3880 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3881 err.span_suggestion(
3883 "try adding a return type",
3884 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3885 Applicability::MachineApplicable);
3888 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3889 err.span_label(span, "possibly return type missing here?");
3892 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3893 // `fn main()` must return `()`, do not suggest changing return type
3894 err.span_label(span, "expected `()` because of default return type");
3897 // expectation was caused by something else, not the default return
3898 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3899 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3900 // Only point to return type if the expected type is the return type, as if they
3901 // are not, the expectation must have been caused by something else.
3902 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3904 let ty = AstConv::ast_ty_to_ty(self, ty);
3905 debug!("suggest_missing_return_type: return type {:?}", ty);
3906 debug!("suggest_missing_return_type: expected type {:?}", ty);
3907 if ty.sty == expected.sty {
3908 err.span_label(sp, format!("expected `{}` because of return type",
3917 /// A common error is to add an extra semicolon:
3920 /// fn foo() -> usize {
3925 /// This routine checks if the final statement in a block is an
3926 /// expression with an explicit semicolon whose type is compatible
3927 /// with `expected_ty`. If so, it suggests removing the semicolon.
3928 fn consider_hint_about_removing_semicolon(
3930 blk: &'tcx hir::Block,
3931 expected_ty: Ty<'tcx>,
3932 err: &mut DiagnosticBuilder<'_>,
3934 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
3935 err.span_suggestion(
3937 "consider removing this semicolon",
3939 Applicability::MachineApplicable,
3944 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
3945 // Be helpful when the user wrote `{... expr;}` and
3946 // taking the `;` off is enough to fix the error.
3947 let last_stmt = blk.stmts.last()?;
3948 let last_expr = match last_stmt.node {
3949 hir::StmtKind::Semi(ref e) => e,
3952 let last_expr_ty = self.node_ty(last_expr.hir_id);
3953 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
3956 let original_span = original_sp(last_stmt.span, blk.span);
3957 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
3960 // Rewrite `SelfCtor` to `Ctor`
3961 pub fn rewrite_self_ctor(
3965 ) -> Result<Res, ErrorReported> {
3967 if let Res::SelfCtor(impl_def_id) = res {
3968 let ty = self.impl_self_ty(span, impl_def_id).ty;
3969 let adt_def = ty.ty_adt_def();
3972 Some(adt_def) if adt_def.has_ctor() => {
3973 let variant = adt_def.non_enum_variant();
3974 let ctor_def_id = variant.ctor_def_id.unwrap();
3975 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
3978 let mut err = tcx.sess.struct_span_err(span,
3979 "the `Self` constructor can only be used with tuple or unit structs");
3980 if let Some(adt_def) = adt_def {
3981 match adt_def.adt_kind() {
3983 err.help("did you mean to use one of the enum's variants?");
3987 err.span_suggestion(
3989 "use curly brackets",
3990 String::from("Self { /* fields */ }"),
3991 Applicability::HasPlaceholders,
4006 // Instantiates the given path, which must refer to an item with the given
4007 // number of type parameters and type.
4008 pub fn instantiate_value_path(&self,
4009 segments: &[hir::PathSegment],
4010 self_ty: Option<Ty<'tcx>>,
4014 -> (Ty<'tcx>, Res) {
4016 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4025 let res = match self.rewrite_self_ctor(res, span) {
4027 Err(ErrorReported) => return (tcx.types.err, res),
4029 let path_segs = match res {
4030 Res::Local(_) => vec![],
4031 Res::Def(kind, def_id) =>
4032 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4033 _ => bug!("instantiate_value_path on {:?}", res),
4036 let mut user_self_ty = None;
4037 let mut is_alias_variant_ctor = false;
4039 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4040 if let Some(self_ty) = self_ty {
4041 let adt_def = self_ty.ty_adt_def().unwrap();
4042 user_self_ty = Some(UserSelfTy {
4043 impl_def_id: adt_def.did,
4046 is_alias_variant_ctor = true;
4049 Res::Def(DefKind::Method, def_id)
4050 | Res::Def(DefKind::AssocConst, def_id) => {
4051 let container = tcx.associated_item(def_id).container;
4052 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4054 ty::TraitContainer(trait_did) => {
4055 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4057 ty::ImplContainer(impl_def_id) => {
4058 if segments.len() == 1 {
4059 // `<T>::assoc` will end up here, and so
4060 // can `T::assoc`. It this came from an
4061 // inherent impl, we need to record the
4062 // `T` for posterity (see `UserSelfTy` for
4064 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4065 user_self_ty = Some(UserSelfTy {
4076 // Now that we have categorized what space the parameters for each
4077 // segment belong to, let's sort out the parameters that the user
4078 // provided (if any) into their appropriate spaces. We'll also report
4079 // errors if type parameters are provided in an inappropriate place.
4081 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4082 let generics_has_err = AstConv::prohibit_generics(
4083 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4084 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4091 if let Res::Local(hid) = res {
4092 let ty = self.local_ty(span, hid).decl_ty;
4093 let ty = self.normalize_associated_types_in(span, &ty);
4094 self.write_ty(hir_id, ty);
4098 if generics_has_err {
4099 // Don't try to infer type parameters when prohibited generic arguments were given.
4100 user_self_ty = None;
4103 // Now we have to compare the types that the user *actually*
4104 // provided against the types that were *expected*. If the user
4105 // did not provide any types, then we want to substitute inference
4106 // variables. If the user provided some types, we may still need
4107 // to add defaults. If the user provided *too many* types, that's
4110 let mut infer_args_for_err = FxHashSet::default();
4111 for &PathSeg(def_id, index) in &path_segs {
4112 let seg = &segments[index];
4113 let generics = tcx.generics_of(def_id);
4114 // Argument-position `impl Trait` is treated as a normal generic
4115 // parameter internally, but we don't allow users to specify the
4116 // parameter's value explicitly, so we have to do some error-
4118 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4123 false, // `is_method_call`
4125 if suppress_errors {
4126 infer_args_for_err.insert(index);
4127 self.set_tainted_by_errors(); // See issue #53251.
4131 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4132 tcx.generics_of(*def_id).has_self
4133 }).unwrap_or(false);
4135 let def_id = res.def_id();
4137 // The things we are substituting into the type should not contain
4138 // escaping late-bound regions, and nor should the base type scheme.
4139 let ty = tcx.type_of(def_id);
4141 let substs = AstConv::create_substs_for_generic_args(
4147 // Provide the generic args, and whether types should be inferred.
4149 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4152 // If we've encountered an `impl Trait`-related error, we're just
4153 // going to infer the arguments for better error messages.
4154 if !infer_args_for_err.contains(&index) {
4155 // Check whether the user has provided generic arguments.
4156 if let Some(ref data) = segments[index].args {
4157 return (Some(data), segments[index].infer_args);
4160 return (None, segments[index].infer_args);
4165 // Provide substitutions for parameters for which (valid) arguments have been provided.
4167 match (¶m.kind, arg) {
4168 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4169 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4171 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4172 self.to_ty(ty).into()
4174 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4175 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4177 _ => unreachable!(),
4180 // Provide substitutions for parameters for which arguments are inferred.
4181 |substs, param, infer_args| {
4183 GenericParamDefKind::Lifetime => {
4184 self.re_infer(Some(param), span).unwrap().into()
4186 GenericParamDefKind::Type { has_default, .. } => {
4187 if !infer_args && has_default {
4188 // If we have a default, then we it doesn't matter that we're not
4189 // inferring the type arguments: we provide the default where any
4191 let default = tcx.type_of(param.def_id);
4194 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4197 // If no type arguments were provided, we have to infer them.
4198 // This case also occurs as a result of some malformed input, e.g.
4199 // a lifetime argument being given instead of a type parameter.
4200 // Using inference instead of `Error` gives better error messages.
4201 self.var_for_def(span, param)
4204 GenericParamDefKind::Const => {
4205 // FIXME(const_generics:defaults)
4206 // No const parameters were provided, we have to infer them.
4207 self.var_for_def(span, param)
4212 assert!(!substs.has_escaping_bound_vars());
4213 assert!(!ty.has_escaping_bound_vars());
4215 // First, store the "user substs" for later.
4216 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4218 // Add all the obligations that are required, substituting and
4219 // normalized appropriately.
4220 let bounds = self.instantiate_bounds(span, def_id, &substs);
4221 self.add_obligations_for_parameters(
4222 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4225 // Substitute the values for the type parameters into the type of
4226 // the referenced item.
4227 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4229 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4230 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4231 // is inherent, there is no `Self` parameter; instead, the impl needs
4232 // type parameters, which we can infer by unifying the provided `Self`
4233 // with the substituted impl type.
4234 // This also occurs for an enum variant on a type alias.
4235 let ty = tcx.type_of(impl_def_id);
4237 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4238 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4239 Ok(ok) => self.register_infer_ok_obligations(ok),
4241 self.tcx.sess.delay_span_bug(span, &format!(
4242 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4250 self.check_rustc_args_require_const(def_id, hir_id, span);
4252 debug!("instantiate_value_path: type of {:?} is {:?}",
4255 self.write_substs(hir_id, substs);
4257 (ty_substituted, res)
4260 fn check_rustc_args_require_const(&self,
4264 // We're only interested in functions tagged with
4265 // #[rustc_args_required_const], so ignore anything that's not.
4266 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4270 // If our calling expression is indeed the function itself, we're good!
4271 // If not, generate an error that this can only be called directly.
4272 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
4273 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
4275 if let ExprKind::Call(ref callee, ..) = expr.node {
4276 if callee.hir_id == hir_id {
4282 self.tcx.sess.span_err(span, "this function can only be invoked \
4283 directly, not through a function pointer");
4286 // Resolves `typ` by a single level if `typ` is a type variable.
4287 // If no resolution is possible, then an error is reported.
4288 // Numeric inference variables may be left unresolved.
4289 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4290 let ty = self.resolve_type_vars_with_obligations(ty);
4291 if !ty.is_ty_var() {
4294 if !self.is_tainted_by_errors() {
4295 self.need_type_info_err((**self).body_id, sp, ty)
4296 .note("type must be known at this point")
4299 self.demand_suptype(sp, self.tcx.types.err, ty);
4304 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4307 ctxt: BreakableCtxt<'tcx>,
4309 ) -> (BreakableCtxt<'tcx>, R) {
4312 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4313 index = enclosing_breakables.stack.len();
4314 enclosing_breakables.by_id.insert(id, index);
4315 enclosing_breakables.stack.push(ctxt);
4319 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4320 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4321 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4322 enclosing_breakables.stack.pop().expect("missing breakable context")
4327 /// Instantiate a QueryResponse in a probe context, without a
4328 /// good ObligationCause.
4329 fn probe_instantiate_query_response(
4332 original_values: &OriginalQueryValues<'tcx>,
4333 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4334 ) -> InferResult<'tcx, Ty<'tcx>>
4336 self.instantiate_query_response_and_region_obligations(
4337 &traits::ObligationCause::misc(span, self.body_id),
4343 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4344 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4345 let mut contained_in_place = false;
4347 while let hir::Node::Expr(parent_expr) =
4348 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
4350 match &parent_expr.node {
4351 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4352 if lhs.hir_id == expr_id {
4353 contained_in_place = true;
4359 expr_id = parent_expr.hir_id;
4366 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4367 let own_counts = generics.own_counts();
4369 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4375 if own_counts.types == 0 {
4379 // Make a vector of booleans initially false, set to true when used.
4380 let mut types_used = vec![false; own_counts.types];
4382 for leaf_ty in ty.walk() {
4383 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4384 debug!("Found use of ty param num {}", index);
4385 types_used[index as usize - own_counts.lifetimes] = true;
4386 } else if let ty::Error = leaf_ty.sty {
4387 // If there is already another error, do not emit
4388 // an error for not using a type Parameter.
4389 assert!(tcx.sess.err_count() > 0);
4394 let types = generics.params.iter().filter(|param| match param.kind {
4395 ty::GenericParamDefKind::Type { .. } => true,
4398 for (&used, param) in types_used.iter().zip(types) {
4400 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4401 let span = tcx.hir().span(id);
4402 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4403 .span_label(span, "unused type parameter")
4409 fn fatally_break_rust(sess: &Session) {
4410 let handler = sess.diagnostic();
4411 handler.span_bug_no_panic(
4413 "It looks like you're trying to break rust; would you like some ICE?",
4415 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4416 handler.note_without_error(
4417 "we would appreciate a joke overview: \
4418 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4420 handler.note_without_error(&format!("rustc {} running on {}",
4421 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4422 crate::session::config::host_triple(),
4426 fn potentially_plural_count(count: usize, word: &str) -> String {
4427 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })