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
84 mod generator_interior;
88 use crate::astconv::{AstConv, PathSeg};
89 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
90 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
91 use rustc::hir::def::{CtorOf, CtorKind, Res, DefKind};
92 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
93 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
94 use rustc::hir::itemlikevisit::ItemLikeVisitor;
95 use crate::middle::lang_items;
96 use crate::namespace::Namespace;
97 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
98 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
99 use rustc_data_structures::indexed_vec::Idx;
100 use rustc_target::spec::abi::Abi;
101 use rustc::infer::opaque_types::OpaqueTypeDecl;
102 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
103 use rustc::middle::region;
104 use rustc::mir::interpret::{ConstValue, GlobalId};
105 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
107 self, AdtKind, CanonicalUserType, Ty, TyCtxt, GenericParamDefKind, Visibility,
108 ToPolyTraitRef, ToPredicate, RegionKind, UserType
110 use rustc::ty::adjustment::{
111 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
113 use rustc::ty::fold::TypeFoldable;
114 use rustc::ty::query::Providers;
115 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
116 use rustc::ty::util::{Representability, IntTypeExt, Discr};
117 use rustc::ty::layout::VariantIdx;
118 use syntax_pos::{self, BytePos, Span, MultiSpan};
119 use syntax_pos::hygiene::CompilerDesugaringKind;
122 use syntax::feature_gate::{GateIssue, emit_feature_err};
124 use syntax::source_map::{DUMMY_SP, original_sp};
125 use syntax::symbol::{Symbol, LocalInternedString, kw, sym};
126 use syntax::util::lev_distance::find_best_match_for_name;
128 use std::cell::{Cell, RefCell, Ref, RefMut};
129 use std::collections::hash_map::Entry;
131 use std::fmt::Display;
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, FxHashMap, 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: 'a> {
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, 'gcx: 'a+'tcx, 'tcx: 'a> {
197 infcx: InferCtxt<'a, 'gcx, '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<'gcx, '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, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
240 type Target = InferCtxt<'a, 'gcx, '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, 'gcx, '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, 'gcx, '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, 'gcx, '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, 'gcx, '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, 'gcx, '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, 'gcx, '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, 'gcx, '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<'gcx: 'tcx, '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<'gcx, 'tcx>>,
501 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
502 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
503 by_id: HirIdMap<usize>,
506 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
507 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, '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, 'gcx: 'a+'tcx, 'tcx: 'a> {
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<'gcx, '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<'gcx, 'tcx>>,
577 inh: &'a Inherited<'a, 'gcx, 'tcx>,
580 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
581 type Target = Inherited<'a, 'gcx, '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 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
590 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
591 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
595 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
596 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
597 -> InheritedBuilder<'a, 'gcx, 'tcx> {
598 let hir_id_root = if def_id.is_local() {
599 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
600 DefId::local(hir_id.owner)
606 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
612 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
613 fn enter<F, R>(&'tcx mut self, f: F) -> R
614 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
616 let def_id = self.def_id;
617 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
621 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
622 fn new(infcx: InferCtxt<'a, 'gcx, '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_by_hir_id(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<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
689 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
690 fn visit_item(&mut self, i: &'tcx hir::Item) {
691 check_item_type(self.tcx, i);
693 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
694 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
697 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
698 tcx.sess.track_errors(|| {
699 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
700 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
704 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
705 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
708 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) {
709 debug_assert!(crate_num == LOCAL_CRATE);
710 tcx.par_body_owners(|body_owner_def_id| {
711 tcx.ensure().typeck_tables_of(body_owner_def_id);
715 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
716 wfcheck::check_item_well_formed(tcx, def_id);
719 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
720 wfcheck::check_trait_item(tcx, def_id);
723 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
724 wfcheck::check_impl_item(tcx, def_id);
727 pub fn provide(providers: &mut Providers<'_>) {
728 method::provide(providers);
729 *providers = Providers {
735 check_item_well_formed,
736 check_trait_item_well_formed,
737 check_impl_item_well_formed,
738 check_mod_item_types,
743 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
745 -> 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<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
760 -> 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<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
802 // Closures' tables come from their outermost function,
803 // as they are part of the same "inference environment".
804 let outer_def_id = tcx.closure_base_def_id(def_id);
805 if outer_def_id != def_id {
806 return tcx.has_typeck_tables(outer_def_id);
809 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
810 primary_body_of(tcx, id).is_some()
813 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
816 &*tcx.typeck_tables_of(def_id).used_trait_imports
819 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
821 -> &'tcx ty::TypeckTables<'tcx> {
822 // Closures' tables come from their outermost function,
823 // as they are part of the same "inference environment".
824 let outer_def_id = tcx.closure_base_def_id(def_id);
825 if outer_def_id != def_id {
826 return tcx.typeck_tables_of(outer_def_id);
829 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
830 let span = tcx.hir().span_by_hir_id(id);
832 // Figure out what primary body this item has.
833 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
834 span_bug!(span, "can't type-check body of {:?}", def_id);
836 let body = tcx.hir().body(body_id);
838 let tables = Inherited::build(tcx, def_id).enter(|inh| {
839 let param_env = tcx.param_env(def_id);
840 let fcx = if let Some(decl) = fn_decl {
841 let fn_sig = tcx.fn_sig(def_id);
843 check_abi(tcx, span, fn_sig.abi());
845 // Compute the fty from point of view of inside the fn.
847 tcx.liberate_late_bound_regions(def_id, &fn_sig);
849 inh.normalize_associated_types_in(body.value.span,
854 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
857 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
858 let expected_type = tcx.type_of(def_id);
859 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
860 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
862 let revealed_ty = if tcx.features().impl_trait_in_bindings {
863 fcx.instantiate_opaque_types_from_value(
871 // Gather locals in statics (because of block expressions).
872 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
874 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
876 fcx.write_ty(id, revealed_ty);
881 // All type checking constraints were added, try to fallback unsolved variables.
882 fcx.select_obligations_where_possible(false);
883 let mut fallback_has_occurred = false;
884 for ty in &fcx.unsolved_variables() {
885 fallback_has_occurred |= fcx.fallback_if_possible(ty);
887 fcx.select_obligations_where_possible(fallback_has_occurred);
889 // Even though coercion casts provide type hints, we check casts after fallback for
890 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
893 // Closure and generator analysis may run after fallback
894 // because they don't constrain other type variables.
895 fcx.closure_analyze(body);
896 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
897 fcx.resolve_generator_interiors(def_id);
899 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
900 let ty = fcx.normalize_ty(span, ty);
901 fcx.require_type_is_sized(ty, span, code);
903 fcx.select_all_obligations_or_error();
905 if fn_decl.is_some() {
906 fcx.regionck_fn(id, body);
908 fcx.regionck_expr(body);
911 fcx.resolve_type_vars_in_body(body)
914 // Consistency check our TypeckTables instance can hold all ItemLocalIds
915 // it will need to hold.
916 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
921 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
922 if !tcx.sess.target.target.is_abi_supported(abi) {
923 struct_span_err!(tcx.sess, span, E0570,
924 "The ABI `{}` is not supported for the current target", abi).emit()
928 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
929 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
930 parent_id: hir::HirId,
933 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
934 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
937 // infer the variable's type
938 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
939 kind: TypeVariableOriginKind::TypeInference,
942 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
949 // take type that the user specified
950 self.fcx.locals.borrow_mut().insert(nid, typ);
957 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
958 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
959 NestedVisitorMap::None
962 // Add explicitly-declared locals.
963 fn visit_local(&mut self, local: &'gcx hir::Local) {
964 let local_ty = match local.ty {
966 let o_ty = self.fcx.to_ty(&ty);
968 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
969 self.fcx.instantiate_opaque_types_from_value(
977 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
978 &UserType::Ty(revealed_ty)
980 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
981 ty.hir_id, o_ty, revealed_ty, c_ty);
982 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
984 Some(LocalTy { decl_ty: o_ty, revealed_ty })
988 self.assign(local.span, local.hir_id, local_ty);
990 debug!("Local variable {:?} is assigned type {}",
992 self.fcx.ty_to_string(
993 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
994 intravisit::walk_local(self, local);
997 // Add pattern bindings.
998 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
999 if let PatKind::Binding(_, _, ident, _) = p.node {
1000 let var_ty = self.assign(p.span, p.hir_id, None);
1002 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
1003 if !self.fcx.tcx.features().unsized_locals {
1004 self.fcx.require_type_is_sized(var_ty, p.span,
1005 traits::VariableType(node_id));
1008 debug!("Pattern binding {} is assigned to {} with type {:?}",
1010 self.fcx.ty_to_string(
1011 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1014 intravisit::walk_pat(self, p);
1017 // Don't descend into the bodies of nested closures
1018 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1019 _: hir::BodyId, _: Span, _: hir::HirId) { }
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, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1043 param_env: ty::ParamEnv<'tcx>,
1044 fn_sig: ty::FnSig<'tcx>,
1045 decl: &'gcx hir::FnDecl,
1047 body: &'gcx hir::Body,
1048 can_be_generator: Option<hir::GeneratorMovability>)
1049 -> (FnCtxt<'a, 'gcx, '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_by_hir_id(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_by_hir_id(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<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1292 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1293 let def = tcx.adt_def(def_id);
1294 def.destructor(tcx); // force the destructor to be evaluated
1295 check_representable(tcx, span, def_id);
1297 if def.repr.simd() {
1298 check_simd(tcx, span, def_id);
1301 check_transparent(tcx, span, def_id);
1302 check_packed(tcx, span, def_id);
1305 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1308 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1309 let def = tcx.adt_def(def_id);
1310 def.destructor(tcx); // force the destructor to be evaluated
1311 check_representable(tcx, span, def_id);
1313 check_packed(tcx, span, def_id);
1316 fn check_opaque<'a, 'tcx>(
1317 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1319 substs: SubstsRef<'tcx>,
1322 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1323 let mut err = struct_span_err!(
1324 tcx.sess, span, E0720,
1325 "opaque type expands to a recursive type",
1327 err.span_label(span, "expands to self-referential type");
1328 if let ty::Opaque(..) = partially_expanded_type.sty {
1329 err.note("type resolves to itself");
1331 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1337 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1339 "check_item_type(it.hir_id={}, it.name={})",
1341 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1343 let _indenter = indenter();
1345 // Consts can play a role in type-checking, so they are included here.
1346 hir::ItemKind::Static(..) => {
1347 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1348 tcx.typeck_tables_of(def_id);
1349 maybe_check_static_with_link_section(tcx, def_id, it.span);
1351 hir::ItemKind::Const(..) => {
1352 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1354 hir::ItemKind::Enum(ref enum_definition, _) => {
1355 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1357 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1358 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1359 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1360 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1361 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1362 check_impl_items_against_trait(
1369 let trait_def_id = impl_trait_ref.def_id;
1370 check_on_unimplemented(tcx, trait_def_id, it);
1373 hir::ItemKind::Trait(..) => {
1374 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1375 check_on_unimplemented(tcx, def_id, it);
1377 hir::ItemKind::Struct(..) => {
1378 check_struct(tcx, it.hir_id, it.span);
1380 hir::ItemKind::Union(..) => {
1381 check_union(tcx, it.hir_id, it.span);
1383 hir::ItemKind::Existential(..) => {
1384 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1386 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1387 check_opaque(tcx, def_id, substs, it.span);
1389 hir::ItemKind::Ty(..) => {
1390 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1391 let pty_ty = tcx.type_of(def_id);
1392 let generics = tcx.generics_of(def_id);
1393 check_bounds_are_used(tcx, &generics, pty_ty);
1395 hir::ItemKind::ForeignMod(ref m) => {
1396 check_abi(tcx, it.span, m.abi);
1398 if m.abi == Abi::RustIntrinsic {
1399 for item in &m.items {
1400 intrinsic::check_intrinsic_type(tcx, item);
1402 } else if m.abi == Abi::PlatformIntrinsic {
1403 for item in &m.items {
1404 intrinsic::check_platform_intrinsic_type(tcx, item);
1407 for item in &m.items {
1408 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1409 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1410 let mut err = struct_span_err!(
1414 "foreign items may not have type parameters"
1416 err.span_label(item.span, "can't have type parameters");
1417 // FIXME: once we start storing spans for type arguments, turn this into a
1420 "use specialization instead of type parameters by replacing them \
1421 with concrete types like `u32`",
1426 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1427 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1432 _ => { /* nothing to do */ }
1436 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1437 // Only restricted on wasm32 target for now
1438 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1442 // If `#[link_section]` is missing, then nothing to verify
1443 let attrs = tcx.codegen_fn_attrs(id);
1444 if attrs.link_section.is_none() {
1448 // For the wasm32 target statics with #[link_section] are placed into custom
1449 // sections of the final output file, but this isn't link custom sections of
1450 // other executable formats. Namely we can only embed a list of bytes,
1451 // nothing with pointers to anything else or relocations. If any relocation
1452 // show up, reject them here.
1453 let instance = ty::Instance::mono(tcx, id);
1454 let cid = GlobalId {
1458 let param_env = ty::ParamEnv::reveal_all();
1459 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1460 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1463 bug!("Matching on non-ByRef static")
1465 if alloc.relocations.len() != 0 {
1466 let msg = "statics with a custom `#[link_section]` must be a \
1467 simple list of bytes on the wasm target with no \
1468 extra levels of indirection such as references";
1469 tcx.sess.span_err(span, msg);
1474 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1475 trait_def_id: DefId,
1477 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1478 // an error would be reported if this fails.
1479 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1482 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1483 impl_item: &hir::ImplItem,
1486 let mut err = struct_span_err!(
1487 tcx.sess, impl_item.span, E0520,
1488 "`{}` specializes an item from a parent `impl`, but \
1489 that item is not marked `default`",
1491 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1494 match tcx.span_of_impl(parent_impl) {
1496 err.span_label(span, "parent `impl` is here");
1497 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1501 err.note(&format!("parent implementation is in crate `{}`", cname));
1508 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1509 trait_def: &ty::TraitDef,
1510 trait_item: &ty::AssocItem,
1512 impl_item: &hir::ImplItem)
1514 let ancestors = trait_def.ancestors(tcx, impl_id);
1516 let kind = match impl_item.node {
1517 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1518 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1519 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1520 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1523 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1524 .map(|node_item| node_item.map(|parent| parent.defaultness));
1526 if let Some(parent) = parent {
1527 if tcx.impl_item_is_final(&parent) {
1528 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1534 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1537 impl_trait_ref: ty::TraitRef<'tcx>,
1538 impl_item_refs: &[hir::ImplItemRef]) {
1539 let impl_span = tcx.sess.source_map().def_span(impl_span);
1541 // If the trait reference itself is erroneous (so the compilation is going
1542 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1543 // isn't populated for such impls.
1544 if impl_trait_ref.references_error() { return; }
1546 // Locate trait definition and items
1547 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1548 let mut overridden_associated_type = None;
1550 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1552 // Check existing impl methods to see if they are both present in trait
1553 // and compatible with trait signature
1554 for impl_item in impl_items() {
1555 let ty_impl_item = tcx.associated_item(
1556 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1557 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1558 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1559 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1561 // Not compatible, but needed for the error message
1562 tcx.associated_items(impl_trait_ref.def_id)
1563 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1566 // Check that impl definition matches trait definition
1567 if let Some(ty_trait_item) = ty_trait_item {
1568 match impl_item.node {
1569 hir::ImplItemKind::Const(..) => {
1570 // Find associated const definition.
1571 if ty_trait_item.kind == ty::AssocKind::Const {
1572 compare_const_impl(tcx,
1578 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1579 "item `{}` is an associated const, \
1580 which doesn't match its trait `{}`",
1583 err.span_label(impl_item.span, "does not match trait");
1584 // We can only get the spans from local trait definition
1585 // Same for E0324 and E0325
1586 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1587 err.span_label(trait_span, "item in trait");
1592 hir::ImplItemKind::Method(..) => {
1593 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1594 if ty_trait_item.kind == ty::AssocKind::Method {
1595 compare_impl_method(tcx,
1602 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1603 "item `{}` is an associated method, \
1604 which doesn't match its trait `{}`",
1607 err.span_label(impl_item.span, "does not match trait");
1608 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1609 err.span_label(trait_span, "item in trait");
1614 hir::ImplItemKind::Existential(..) |
1615 hir::ImplItemKind::Type(_) => {
1616 if ty_trait_item.kind == ty::AssocKind::Type {
1617 if ty_trait_item.defaultness.has_value() {
1618 overridden_associated_type = Some(impl_item);
1621 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1622 "item `{}` is an associated type, \
1623 which doesn't match its trait `{}`",
1626 err.span_label(impl_item.span, "does not match trait");
1627 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1628 err.span_label(trait_span, "item in trait");
1635 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1639 // Check for missing items from trait
1640 let mut missing_items = Vec::new();
1641 let mut invalidated_items = Vec::new();
1642 let associated_type_overridden = overridden_associated_type.is_some();
1643 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1644 let is_implemented = trait_def.ancestors(tcx, impl_id)
1645 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1647 .map(|node_item| !node_item.node.is_from_trait())
1650 if !is_implemented && !tcx.impl_is_default(impl_id) {
1651 if !trait_item.defaultness.has_value() {
1652 missing_items.push(trait_item);
1653 } else if associated_type_overridden {
1654 invalidated_items.push(trait_item.ident);
1659 if !missing_items.is_empty() {
1660 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1661 "not all trait items implemented, missing: `{}`",
1662 missing_items.iter()
1663 .map(|trait_item| trait_item.ident.to_string())
1664 .collect::<Vec<_>>().join("`, `"));
1665 err.span_label(impl_span, format!("missing `{}` in implementation",
1666 missing_items.iter()
1667 .map(|trait_item| trait_item.ident.to_string())
1668 .collect::<Vec<_>>().join("`, `")));
1669 for trait_item in missing_items {
1670 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1671 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1673 err.note_trait_signature(trait_item.ident.to_string(),
1674 trait_item.signature(tcx));
1680 if !invalidated_items.is_empty() {
1681 let invalidator = overridden_associated_type.unwrap();
1682 span_err!(tcx.sess, invalidator.span, E0399,
1683 "the following trait items need to be reimplemented \
1684 as `{}` was overridden: `{}`",
1686 invalidated_items.iter()
1687 .map(|name| name.to_string())
1688 .collect::<Vec<_>>().join("`, `"))
1692 /// Checks whether a type can be represented in memory. In particular, it
1693 /// identifies types that contain themselves without indirection through a
1694 /// pointer, which would mean their size is unbounded.
1695 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1699 let rty = tcx.type_of(item_def_id);
1701 // Check that it is possible to represent this type. This call identifies
1702 // (1) types that contain themselves and (2) types that contain a different
1703 // recursive type. It is only necessary to throw an error on those that
1704 // contain themselves. For case 2, there must be an inner type that will be
1705 // caught by case 1.
1706 match rty.is_representable(tcx, sp) {
1707 Representability::SelfRecursive(spans) => {
1708 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1710 err.span_label(span, "recursive without indirection");
1715 Representability::Representable | Representability::ContainsRecursive => (),
1720 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1721 let t = tcx.type_of(def_id);
1722 if let ty::Adt(def, substs) = t.sty {
1723 if def.is_struct() {
1724 let fields = &def.non_enum_variant().fields;
1725 if fields.is_empty() {
1726 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1729 let e = fields[0].ty(tcx, substs);
1730 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1731 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1732 .span_label(sp, "SIMD elements must have the same type")
1737 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1738 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1740 span_err!(tcx.sess, sp, E0077,
1741 "SIMD vector element type should be machine type");
1749 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1750 let repr = tcx.adt_def(def_id).repr;
1752 for attr in tcx.get_attrs(def_id).iter() {
1753 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1754 if let attr::ReprPacked(pack) = r {
1755 if pack != repr.pack {
1756 struct_span_err!(tcx.sess, sp, E0634,
1757 "type has conflicting packed representation hints").emit();
1763 struct_span_err!(tcx.sess, sp, E0587,
1764 "type has conflicting packed and align representation hints").emit();
1766 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1767 struct_span_err!(tcx.sess, sp, E0588,
1768 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1773 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1775 stack: &mut Vec<DefId>) -> bool {
1776 let t = tcx.type_of(def_id);
1777 if stack.contains(&def_id) {
1778 debug!("check_packed_inner: {:?} is recursive", t);
1781 if let ty::Adt(def, substs) = t.sty {
1782 if def.is_struct() || def.is_union() {
1783 if tcx.adt_def(def.did).repr.align > 0 {
1786 // push struct def_id before checking fields
1788 for field in &def.non_enum_variant().fields {
1789 let f = field.ty(tcx, substs);
1790 if let ty::Adt(def, _) = f.sty {
1791 if check_packed_inner(tcx, def.did, stack) {
1796 // only need to pop if not early out
1803 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1804 let adt = tcx.adt_def(def_id);
1805 if !adt.repr.transparent() {
1809 // For each field, figure out if it's known to be a ZST and align(1)
1810 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1811 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1812 let param_env = tcx.param_env(field.did);
1813 let layout = tcx.layout_of(param_env.and(ty));
1814 // We are currently checking the type this field came from, so it must be local
1815 let span = tcx.hir().span_if_local(field.did).unwrap();
1816 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1817 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1821 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1822 let non_zst_count = non_zst_fields.clone().count();
1823 if non_zst_count != 1 {
1824 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1825 struct_span_err!(tcx.sess, sp, E0690,
1826 "transparent struct needs exactly one non-zero-sized field, but has {}",
1828 .span_note(field_spans, "non-zero-sized field")
1831 for (span, zst, align1) in field_infos {
1833 span_err!(tcx.sess, span, E0691,
1834 "zero-sized field in transparent struct has alignment larger than 1");
1839 #[allow(trivial_numeric_casts)]
1840 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1842 vs: &'tcx [hir::Variant],
1844 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1845 let def = tcx.adt_def(def_id);
1846 def.destructor(tcx); // force the destructor to be evaluated
1849 let attributes = tcx.get_attrs(def_id);
1850 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1852 tcx.sess, attr.span, E0084,
1853 "unsupported representation for zero-variant enum")
1854 .span_label(sp, "zero-variant enum")
1859 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1860 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1861 if !tcx.features().repr128 {
1862 emit_feature_err(&tcx.sess.parse_sess,
1865 GateIssue::Language,
1866 "repr with 128-bit type is unstable");
1871 if let Some(ref e) = v.node.disr_expr {
1872 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1876 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1877 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1878 // Check for duplicate discriminant values
1879 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1880 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1881 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1882 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1883 let i_span = match variant_i.node.disr_expr {
1884 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1885 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1887 let span = match v.node.disr_expr {
1888 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1891 struct_span_err!(tcx.sess, span, E0081,
1892 "discriminant value `{}` already exists", disr_vals[i])
1893 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1894 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1897 disr_vals.push(discr);
1900 check_representable(tcx, sp, def_id);
1903 fn report_unexpected_variant_res<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1907 span_err!(tcx.sess, span, E0533,
1908 "expected unit struct/variant or constant, found {} `{}`",
1910 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1913 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1914 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1916 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1917 -> &'tcx ty::GenericPredicates<'tcx>
1920 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1921 let item_id = tcx.hir().ty_param_owner(hir_id);
1922 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1923 let generics = tcx.generics_of(item_def_id);
1924 let index = generics.param_def_id_to_index[&def_id];
1925 tcx.arena.alloc(ty::GenericPredicates {
1927 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1929 ty::Predicate::Trait(ref data)
1930 if data.skip_binder().self_ty().is_param(index) => {
1931 // HACK(eddyb) should get the original `Span`.
1932 let span = tcx.def_span(def_id);
1933 Some((predicate, span))
1941 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1942 -> Option<ty::Region<'tcx>> {
1944 Some(def) => infer::EarlyBoundRegion(span, def.name),
1945 None => infer::MiscVariable(span)
1947 Some(self.next_region_var(v))
1950 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1951 self.next_ty_var(TypeVariableOrigin {
1952 kind: TypeVariableOriginKind::TypeInference,
1957 fn ty_infer_for_def(&self,
1958 ty_param_def: &ty::GenericParamDef,
1959 span: Span) -> Ty<'tcx> {
1960 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1966 fn projected_ty_from_poly_trait_ref(&self,
1969 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1972 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1974 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1978 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1981 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1982 if ty.has_escaping_bound_vars() {
1983 ty // FIXME: normalization and escaping regions
1985 self.normalize_associated_types_in(span, &ty)
1989 fn set_tainted_by_errors(&self) {
1990 self.infcx.set_tainted_by_errors()
1993 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1994 self.write_ty(hir_id, ty)
1998 /// Controls whether the arguments are tupled. This is used for the call
2001 /// Tupling means that all call-side arguments are packed into a tuple and
2002 /// passed as a single parameter. For example, if tupling is enabled, this
2005 /// fn f(x: (isize, isize))
2007 /// Can be called as:
2014 #[derive(Clone, Eq, PartialEq)]
2015 enum TupleArgumentsFlag {
2020 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2021 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2022 param_env: ty::ParamEnv<'tcx>,
2023 body_id: hir::HirId)
2024 -> FnCtxt<'a, 'gcx, 'tcx> {
2028 err_count_on_creation: inh.tcx.sess.err_count(),
2030 ret_coercion_span: RefCell::new(None),
2032 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2033 hir::CRATE_HIR_ID)),
2034 diverges: Cell::new(Diverges::Maybe),
2035 has_errors: Cell::new(false),
2036 enclosing_breakables: RefCell::new(EnclosingBreakables {
2038 by_id: Default::default(),
2044 pub fn sess(&self) -> &Session {
2048 pub fn err_count_since_creation(&self) -> usize {
2049 self.tcx.sess.err_count() - self.err_count_on_creation
2052 /// Produces warning on the given node, if the current point in the
2053 /// function is unreachable, and there hasn't been another warning.
2054 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2055 if self.diverges.get() == Diverges::Always &&
2056 // If span arose from a desugaring of `if` then it is the condition itself,
2057 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2058 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2059 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2060 self.diverges.set(Diverges::WarnedAlways);
2062 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2064 let msg = format!("unreachable {}", kind);
2065 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2071 code: ObligationCauseCode<'tcx>)
2072 -> ObligationCause<'tcx> {
2073 ObligationCause::new(span, self.body_id, code)
2076 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2077 self.cause(span, ObligationCauseCode::MiscObligation)
2080 /// Resolves type variables in `ty` if possible. Unlike the infcx
2081 /// version (resolve_vars_if_possible), this version will
2082 /// also select obligations if it seems useful, in an effort
2083 /// to get more type information.
2084 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2085 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2087 // No Infer()? Nothing needs doing.
2088 if !ty.has_infer_types() {
2089 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2093 // If `ty` is a type variable, see whether we already know what it is.
2094 ty = self.resolve_vars_if_possible(&ty);
2095 if !ty.has_infer_types() {
2096 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2100 // If not, try resolving pending obligations as much as
2101 // possible. This can help substantially when there are
2102 // indirect dependencies that don't seem worth tracking
2104 self.select_obligations_where_possible(false);
2105 ty = self.resolve_vars_if_possible(&ty);
2107 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2111 fn record_deferred_call_resolution(&self,
2112 closure_def_id: DefId,
2113 r: DeferredCallResolution<'gcx, 'tcx>) {
2114 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2115 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2118 fn remove_deferred_call_resolutions(&self,
2119 closure_def_id: DefId)
2120 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2122 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2123 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2126 pub fn tag(&self) -> String {
2127 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2128 format!("{:?}", self_ptr)
2131 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2132 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2133 span_bug!(span, "no type for local variable {}",
2134 self.tcx.hir().hir_to_string(nid))
2139 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2140 debug!("write_ty({:?}, {:?}) in fcx {}",
2141 id, self.resolve_vars_if_possible(&ty), self.tag());
2142 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2144 if ty.references_error() {
2145 self.has_errors.set(true);
2146 self.set_tainted_by_errors();
2150 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2151 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2154 pub fn write_method_call(&self,
2156 method: MethodCallee<'tcx>) {
2157 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2160 .type_dependent_defs_mut()
2161 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2163 self.write_substs(hir_id, method.substs);
2165 // When the method is confirmed, the `method.substs` includes
2166 // parameters from not just the method, but also the impl of
2167 // the method -- in particular, the `Self` type will be fully
2168 // resolved. However, those are not something that the "user
2169 // specified" -- i.e., those types come from the inferred type
2170 // of the receiver, not something the user wrote. So when we
2171 // create the user-substs, we want to replace those earlier
2172 // types with just the types that the user actually wrote --
2173 // that is, those that appear on the *method itself*.
2175 // As an example, if the user wrote something like
2176 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2177 // type of `foo` (possibly adjusted), but we don't want to
2178 // include that. We want just the `[_, u32]` part.
2179 if !method.substs.is_noop() {
2180 let method_generics = self.tcx.generics_of(method.def_id);
2181 if !method_generics.params.is_empty() {
2182 let user_type_annotation = self.infcx.probe(|_| {
2183 let user_substs = UserSubsts {
2184 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2185 let i = param.index as usize;
2186 if i < method_generics.parent_count {
2187 self.infcx.var_for_def(DUMMY_SP, param)
2192 user_self_ty: None, // not relevant here
2195 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2201 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2202 self.write_user_type_annotation(hir_id, user_type_annotation);
2207 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2208 if !substs.is_noop() {
2209 debug!("write_substs({:?}, {:?}) in fcx {}",
2214 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2218 /// Given the substs that we just converted from the HIR, try to
2219 /// canonicalize them and store them as user-given substitutions
2220 /// (i.e., substitutions that must be respected by the NLL check).
2222 /// This should be invoked **before any unifications have
2223 /// occurred**, so that annotations like `Vec<_>` are preserved
2225 pub fn write_user_type_annotation_from_substs(
2229 substs: SubstsRef<'tcx>,
2230 user_self_ty: Option<UserSelfTy<'tcx>>,
2233 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2234 user_self_ty={:?} in fcx {}",
2235 hir_id, def_id, substs, user_self_ty, self.tag(),
2238 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2239 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2240 &UserType::TypeOf(def_id, UserSubsts {
2245 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2246 self.write_user_type_annotation(hir_id, canonicalized);
2250 pub fn write_user_type_annotation(
2253 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2256 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2257 hir_id, canonical_user_type_annotation, self.tag(),
2260 if !canonical_user_type_annotation.is_identity() {
2261 self.tables.borrow_mut().user_provided_types_mut().insert(
2262 hir_id, canonical_user_type_annotation
2265 debug!("write_user_type_annotation: skipping identity substs");
2269 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2270 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2276 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2277 Entry::Vacant(entry) => { entry.insert(adj); },
2278 Entry::Occupied(mut entry) => {
2279 debug!(" - composing on top of {:?}", entry.get());
2280 match (&entry.get()[..], &adj[..]) {
2281 // Applying any adjustment on top of a NeverToAny
2282 // is a valid NeverToAny adjustment, because it can't
2284 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2286 Adjustment { kind: Adjust::Deref(_), .. },
2287 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2289 Adjustment { kind: Adjust::Deref(_), .. },
2290 .. // Any following adjustments are allowed.
2292 // A reborrow has no effect before a dereference.
2294 // FIXME: currently we never try to compose autoderefs
2295 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2297 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2298 expr, entry.get(), adj)
2300 *entry.get_mut() = adj;
2305 /// Basically whenever we are converting from a type scheme into
2306 /// the fn body space, we always want to normalize associated
2307 /// types as well. This function combines the two.
2308 fn instantiate_type_scheme<T>(&self,
2310 substs: SubstsRef<'tcx>,
2313 where T : TypeFoldable<'tcx>
2315 let value = value.subst(self.tcx, substs);
2316 let result = self.normalize_associated_types_in(span, &value);
2317 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2324 /// As `instantiate_type_scheme`, but for the bounds found in a
2325 /// generic type scheme.
2326 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2327 -> ty::InstantiatedPredicates<'tcx> {
2328 let bounds = self.tcx.predicates_of(def_id);
2329 let result = bounds.instantiate(self.tcx, substs);
2330 let result = self.normalize_associated_types_in(span, &result);
2331 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2338 /// Replaces the opaque types from the given value with type variables,
2339 /// and records the `OpaqueTypeMap` for later use during writeback. See
2340 /// `InferCtxt::instantiate_opaque_types` for more details.
2341 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2343 parent_id: hir::HirId,
2346 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2347 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2351 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2352 self.instantiate_opaque_types(
2360 let mut opaque_types = self.opaque_types.borrow_mut();
2361 for (ty, decl) in opaque_type_map {
2362 let old_value = opaque_types.insert(ty, decl);
2363 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2369 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2370 where T : TypeFoldable<'tcx>
2372 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2375 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2377 where T : TypeFoldable<'tcx>
2379 self.inh.partially_normalize_associated_types_in(span,
2385 pub fn require_type_meets(&self,
2388 code: traits::ObligationCauseCode<'tcx>,
2391 self.register_bound(
2394 traits::ObligationCause::new(span, self.body_id, code));
2397 pub fn require_type_is_sized(&self,
2400 code: traits::ObligationCauseCode<'tcx>)
2402 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2403 self.require_type_meets(ty, span, code, lang_item);
2406 pub fn require_type_is_sized_deferred(&self,
2409 code: traits::ObligationCauseCode<'tcx>)
2411 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2414 pub fn register_bound(&self,
2417 cause: traits::ObligationCause<'tcx>)
2419 self.fulfillment_cx.borrow_mut()
2420 .register_bound(self, self.param_env, ty, def_id, cause);
2423 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2424 let t = AstConv::ast_ty_to_ty(self, ast_t);
2425 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2429 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2430 let ty = self.to_ty(ast_ty);
2431 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2433 if Self::can_contain_user_lifetime_bounds(ty) {
2434 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2435 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2436 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2442 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2443 AstConv::ast_const_to_const(self, ast_c, ty)
2446 // If the type given by the user has free regions, save it for later, since
2447 // NLL would like to enforce those. Also pass in types that involve
2448 // projections, since those can resolve to `'static` bounds (modulo #54940,
2449 // which hopefully will be fixed by the time you see this comment, dear
2450 // reader, although I have my doubts). Also pass in types with inference
2451 // types, because they may be repeated. Other sorts of things are already
2452 // sufficiently enforced with erased regions. =)
2453 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2455 T: TypeFoldable<'tcx>
2457 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2460 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2461 match self.tables.borrow().node_types().get(id) {
2463 None if self.is_tainted_by_errors() => self.tcx.types.err,
2465 let node_id = self.tcx.hir().hir_to_node_id(id);
2466 bug!("no type for node {}: {} in fcx {}",
2467 node_id, self.tcx.hir().node_to_string(node_id),
2473 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2474 /// outlive the region `r`.
2475 pub fn register_wf_obligation(&self,
2478 code: traits::ObligationCauseCode<'tcx>)
2480 // WF obligations never themselves fail, so no real need to give a detailed cause:
2481 let cause = traits::ObligationCause::new(span, self.body_id, code);
2482 self.register_predicate(traits::Obligation::new(cause,
2484 ty::Predicate::WellFormed(ty)));
2487 /// Registers obligations that all types appearing in `substs` are well-formed.
2488 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2489 for ty in substs.types() {
2490 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2494 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2495 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2496 /// trait/region obligations.
2498 /// For example, if there is a function:
2501 /// fn foo<'a,T:'a>(...)
2504 /// and a reference:
2510 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2511 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2512 pub fn add_obligations_for_parameters(&self,
2513 cause: traits::ObligationCause<'tcx>,
2514 predicates: &ty::InstantiatedPredicates<'tcx>)
2516 assert!(!predicates.has_escaping_bound_vars());
2518 debug!("add_obligations_for_parameters(predicates={:?})",
2521 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2522 self.register_predicate(obligation);
2526 // FIXME(arielb1): use this instead of field.ty everywhere
2527 // Only for fields! Returns <none> for methods>
2528 // Indifferent to privacy flags
2529 pub fn field_ty(&self,
2531 field: &'tcx ty::FieldDef,
2532 substs: SubstsRef<'tcx>)
2535 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2538 fn check_casts(&self) {
2539 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2540 for cast in deferred_cast_checks.drain(..) {
2545 fn resolve_generator_interiors(&self, def_id: DefId) {
2546 let mut generators = self.deferred_generator_interiors.borrow_mut();
2547 for (body_id, interior) in generators.drain(..) {
2548 self.select_obligations_where_possible(false);
2549 generator_interior::resolve_interior(self, def_id, body_id, interior);
2553 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2554 // Non-numerics get replaced with ! or () (depending on whether
2555 // feature(never_type) is enabled, unconstrained ints with i32,
2556 // unconstrained floats with f64.
2557 // Fallback becomes very dubious if we have encountered type-checking errors.
2558 // In that case, fallback to Error.
2559 // The return value indicates whether fallback has occurred.
2560 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2561 use rustc::ty::error::UnconstrainedNumeric::Neither;
2562 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2564 assert!(ty.is_ty_infer());
2565 let fallback = match self.type_is_unconstrained_numeric(ty) {
2566 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2567 UnconstrainedInt => self.tcx.types.i32,
2568 UnconstrainedFloat => self.tcx.types.f64,
2569 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2570 Neither => return false,
2572 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2573 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2577 fn select_all_obligations_or_error(&self) {
2578 debug!("select_all_obligations_or_error");
2579 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2580 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2584 /// Select as many obligations as we can at present.
2585 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2586 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2587 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2591 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2592 /// returns a type of `&T`, but the actual type we assign to the
2593 /// *expression* is `T`. So this function just peels off the return
2594 /// type by one layer to yield `T`.
2595 fn make_overloaded_place_return_type(&self,
2596 method: MethodCallee<'tcx>)
2597 -> ty::TypeAndMut<'tcx>
2599 // extract method return type, which will be &T;
2600 let ret_ty = method.sig.output();
2602 // method returns &T, but the type as visible to user is T, so deref
2603 ret_ty.builtin_deref(true).unwrap()
2606 fn lookup_indexing(&self,
2608 base_expr: &'gcx hir::Expr,
2612 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2614 // FIXME(#18741) -- this is almost but not quite the same as the
2615 // autoderef that normal method probing does. They could likely be
2618 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2619 let mut result = None;
2620 while result.is_none() && autoderef.next().is_some() {
2621 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2623 autoderef.finalize(self);
2627 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2628 /// (and otherwise adjust) `base_expr`, looking for a type which either
2629 /// supports builtin indexing or overloaded indexing.
2630 /// This loop implements one step in that search; the autoderef loop
2631 /// is implemented by `lookup_indexing`.
2632 fn try_index_step(&self,
2634 base_expr: &hir::Expr,
2635 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2638 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2640 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2641 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2648 for &unsize in &[false, true] {
2649 let mut self_ty = adjusted_ty;
2651 // We only unsize arrays here.
2652 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2653 self_ty = self.tcx.mk_slice(element_ty);
2659 // If some lookup succeeds, write callee into table and extract index/element
2660 // type from the method signature.
2661 // If some lookup succeeded, install method in table
2662 let input_ty = self.next_ty_var(TypeVariableOrigin {
2663 kind: TypeVariableOriginKind::AutoDeref,
2664 span: base_expr.span,
2666 let method = self.try_overloaded_place_op(
2667 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2669 let result = method.map(|ok| {
2670 debug!("try_index_step: success, using overloaded indexing");
2671 let method = self.register_infer_ok_obligations(ok);
2673 let mut adjustments = autoderef.adjust_steps(self, needs);
2674 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2675 let mutbl = match r_mutbl {
2676 hir::MutImmutable => AutoBorrowMutability::Immutable,
2677 hir::MutMutable => AutoBorrowMutability::Mutable {
2678 // Indexing can be desugared to a method call,
2679 // so maybe we could use two-phase here.
2680 // See the documentation of AllowTwoPhase for why that's
2681 // not the case today.
2682 allow_two_phase_borrow: AllowTwoPhase::No,
2685 adjustments.push(Adjustment {
2686 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2687 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2694 adjustments.push(Adjustment {
2695 kind: Adjust::Pointer(PointerCast::Unsize),
2696 target: method.sig.inputs()[0]
2699 self.apply_adjustments(base_expr, adjustments);
2701 self.write_method_call(expr.hir_id, method);
2702 (input_ty, self.make_overloaded_place_return_type(method).ty)
2704 if result.is_some() {
2712 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2713 let (tr, name) = match (op, is_mut) {
2714 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2715 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2716 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2717 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2719 (tr, ast::Ident::with_empty_ctxt(name))
2722 fn try_overloaded_place_op(&self,
2725 arg_tys: &[Ty<'tcx>],
2728 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2730 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2736 // Try Mut first, if needed.
2737 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2738 let method = match (needs, mut_tr) {
2739 (Needs::MutPlace, Some(trait_did)) => {
2740 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2745 // Otherwise, fall back to the immutable version.
2746 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2747 let method = match (method, imm_tr) {
2748 (None, Some(trait_did)) => {
2749 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2751 (method, _) => method,
2757 fn check_method_argument_types(&self,
2760 method: Result<MethodCallee<'tcx>, ()>,
2761 args_no_rcvr: &'gcx [hir::Expr],
2762 tuple_arguments: TupleArgumentsFlag,
2763 expected: Expectation<'tcx>)
2765 let has_error = match method {
2767 method.substs.references_error() || method.sig.references_error()
2772 let err_inputs = self.err_args(args_no_rcvr.len());
2774 let err_inputs = match tuple_arguments {
2775 DontTupleArguments => err_inputs,
2776 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2779 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2780 false, tuple_arguments, None);
2781 return self.tcx.types.err;
2784 let method = method.unwrap();
2785 // HACK(eddyb) ignore self in the definition (see above).
2786 let expected_arg_tys = self.expected_inputs_for_expected_output(
2789 method.sig.output(),
2790 &method.sig.inputs()[1..]
2792 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2793 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2794 self.tcx.hir().span_if_local(method.def_id));
2798 fn self_type_matches_expected_vid(
2800 trait_ref: ty::PolyTraitRef<'tcx>,
2801 expected_vid: ty::TyVid,
2803 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2805 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2806 trait_ref, self_ty, expected_vid
2809 ty::Infer(ty::TyVar(found_vid)) => {
2810 // FIXME: consider using `sub_root_var` here so we
2811 // can see through subtyping.
2812 let found_vid = self.root_var(found_vid);
2813 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2814 expected_vid == found_vid
2820 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2821 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2822 + Captures<'gcx> + 'b
2824 // FIXME: consider using `sub_root_var` here so we
2825 // can see through subtyping.
2826 let ty_var_root = self.root_var(self_ty);
2827 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2828 self_ty, ty_var_root,
2829 self.fulfillment_cx.borrow().pending_obligations());
2833 .pending_obligations()
2835 .filter_map(move |obligation| match obligation.predicate {
2836 ty::Predicate::Projection(ref data) =>
2837 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2838 ty::Predicate::Trait(ref data) =>
2839 Some((data.to_poly_trait_ref(), obligation)),
2840 ty::Predicate::Subtype(..) => None,
2841 ty::Predicate::RegionOutlives(..) => None,
2842 ty::Predicate::TypeOutlives(..) => None,
2843 ty::Predicate::WellFormed(..) => None,
2844 ty::Predicate::ObjectSafe(..) => None,
2845 ty::Predicate::ConstEvaluatable(..) => None,
2846 // N.B., this predicate is created by breaking down a
2847 // `ClosureType: FnFoo()` predicate, where
2848 // `ClosureType` represents some `Closure`. It can't
2849 // possibly be referring to the current closure,
2850 // because we haven't produced the `Closure` for
2851 // this closure yet; this is exactly why the other
2852 // code is looking for a self type of a unresolved
2853 // inference variable.
2854 ty::Predicate::ClosureKind(..) => None,
2855 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2858 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2859 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2860 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2864 /// Generic function that factors out common logic from function calls,
2865 /// method calls and overloaded operators.
2866 fn check_argument_types(&self,
2869 fn_inputs: &[Ty<'tcx>],
2870 expected_arg_tys: &[Ty<'tcx>],
2871 args: &'gcx [hir::Expr],
2873 tuple_arguments: TupleArgumentsFlag,
2874 def_span: Option<Span>) {
2877 // Grab the argument types, supplying fresh type variables
2878 // if the wrong number of arguments were supplied
2879 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2885 // All the input types from the fn signature must outlive the call
2886 // so as to validate implied bounds.
2887 for &fn_input_ty in fn_inputs {
2888 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2891 let expected_arg_count = fn_inputs.len();
2893 let param_count_error = |expected_count: usize,
2898 let mut err = tcx.sess.struct_span_err_with_code(sp,
2899 &format!("this function takes {}{} but {} {} supplied",
2900 if c_variadic { "at least " } else { "" },
2901 potentially_plural_count(expected_count, "parameter"),
2902 potentially_plural_count(arg_count, "parameter"),
2903 if arg_count == 1 {"was"} else {"were"}),
2904 DiagnosticId::Error(error_code.to_owned()));
2906 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2907 err.span_label(def_s, "defined here");
2910 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2911 // remove closing `)` from the span
2912 let sugg_span = sugg_span.shrink_to_lo();
2913 err.span_suggestion(
2915 "expected the unit value `()`; create it with empty parentheses",
2917 Applicability::MachineApplicable);
2919 err.span_label(sp, format!("expected {}{}",
2920 if c_variadic { "at least " } else { "" },
2921 potentially_plural_count(expected_count, "parameter")));
2926 let mut expected_arg_tys = expected_arg_tys.to_vec();
2928 let formal_tys = if tuple_arguments == TupleArguments {
2929 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2930 match tuple_type.sty {
2931 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2932 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2933 expected_arg_tys = vec![];
2934 self.err_args(args.len())
2936 ty::Tuple(arg_types) => {
2937 expected_arg_tys = match expected_arg_tys.get(0) {
2938 Some(&ty) => match ty.sty {
2939 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
2944 arg_types.iter().map(|k| k.expect_ty()).collect()
2947 span_err!(tcx.sess, sp, E0059,
2948 "cannot use call notation; the first type parameter \
2949 for the function trait is neither a tuple nor unit");
2950 expected_arg_tys = vec![];
2951 self.err_args(args.len())
2954 } else if expected_arg_count == supplied_arg_count {
2956 } else if c_variadic {
2957 if supplied_arg_count >= expected_arg_count {
2960 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2961 expected_arg_tys = vec![];
2962 self.err_args(supplied_arg_count)
2965 // is the missing argument of type `()`?
2966 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2967 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
2968 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2969 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
2973 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2975 expected_arg_tys = vec![];
2976 self.err_args(supplied_arg_count)
2979 debug!("check_argument_types: formal_tys={:?}",
2980 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2982 // If there is no expectation, expect formal_tys.
2983 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2989 // Check the arguments.
2990 // We do this in a pretty awful way: first we type-check any arguments
2991 // that are not closures, then we type-check the closures. This is so
2992 // that we have more information about the types of arguments when we
2993 // type-check the functions. This isn't really the right way to do this.
2994 for &check_closures in &[false, true] {
2995 debug!("check_closures={}", check_closures);
2997 // More awful hacks: before we check argument types, try to do
2998 // an "opportunistic" vtable resolution of any trait bounds on
2999 // the call. This helps coercions.
3001 self.select_obligations_where_possible(false);
3004 // For C-variadic functions, we don't have a declared type for all of
3005 // the arguments hence we only do our usual type checking with
3006 // the arguments who's types we do know.
3007 let t = if c_variadic {
3009 } else if tuple_arguments == TupleArguments {
3014 for (i, arg) in args.iter().take(t).enumerate() {
3015 // Warn only for the first loop (the "no closures" one).
3016 // Closure arguments themselves can't be diverging, but
3017 // a previous argument can, e.g., `foo(panic!(), || {})`.
3018 if !check_closures {
3019 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3022 let is_closure = match arg.node {
3023 ExprKind::Closure(..) => true,
3027 if is_closure != check_closures {
3031 debug!("checking the argument");
3032 let formal_ty = formal_tys[i];
3034 // The special-cased logic below has three functions:
3035 // 1. Provide as good of an expected type as possible.
3036 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3038 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3040 // 2. Coerce to the most detailed type that could be coerced
3041 // to, which is `expected_ty` if `rvalue_hint` returns an
3042 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3043 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3044 // We're processing function arguments so we definitely want to use
3045 // two-phase borrows.
3046 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3048 // 3. Relate the expected type and the formal one,
3049 // if the expected type was used for the coercion.
3050 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3054 // We also need to make sure we at least write the ty of the other
3055 // arguments which we skipped above.
3057 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3058 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3059 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3062 for arg in args.iter().skip(expected_arg_count) {
3063 let arg_ty = self.check_expr(&arg);
3065 // There are a few types which get autopromoted when passed via varargs
3066 // in C but we just error out instead and require explicit casts.
3067 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3069 ty::Float(ast::FloatTy::F32) => {
3070 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3072 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3073 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3075 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3076 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3079 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3080 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3081 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3089 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3090 vec![self.tcx.types.err; len]
3093 // AST fragment checking
3096 expected: Expectation<'tcx>)
3102 ast::LitKind::Str(..) => tcx.mk_static_str(),
3103 ast::LitKind::ByteStr(ref v) => {
3104 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3105 tcx.mk_array(tcx.types.u8, v.len() as u64))
3107 ast::LitKind::Byte(_) => tcx.types.u8,
3108 ast::LitKind::Char(_) => tcx.types.char,
3109 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3110 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3111 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3112 let opt_ty = expected.to_option(self).and_then(|ty| {
3114 ty::Int(_) | ty::Uint(_) => Some(ty),
3115 ty::Char => Some(tcx.types.u8),
3116 ty::RawPtr(..) => Some(tcx.types.usize),
3117 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3121 opt_ty.unwrap_or_else(|| self.next_int_var())
3123 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3124 ast::LitKind::FloatUnsuffixed(_) => {
3125 let opt_ty = expected.to_option(self).and_then(|ty| {
3127 ty::Float(_) => Some(ty),
3131 opt_ty.unwrap_or_else(|| self.next_float_var())
3133 ast::LitKind::Bool(_) => tcx.types.bool,
3134 ast::LitKind::Err(_) => tcx.types.err,
3138 fn check_expr_eq_type(&self,
3139 expr: &'gcx hir::Expr,
3140 expected: Ty<'tcx>) {
3141 let ty = self.check_expr_with_hint(expr, expected);
3142 self.demand_eqtype(expr.span, expected, ty);
3145 pub fn check_expr_has_type_or_error(&self,
3146 expr: &'gcx hir::Expr,
3147 expected: Ty<'tcx>) -> Ty<'tcx> {
3148 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3151 fn check_expr_meets_expectation_or_error(&self,
3152 expr: &'gcx hir::Expr,
3153 expected: Expectation<'tcx>) -> Ty<'tcx> {
3154 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3155 let mut ty = self.check_expr_with_expectation(expr, expected);
3157 // While we don't allow *arbitrary* coercions here, we *do* allow
3158 // coercions from ! to `expected`.
3160 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3161 "expression with never type wound up being adjusted");
3162 let adj_ty = self.next_diverging_ty_var(
3163 TypeVariableOrigin {
3164 kind: TypeVariableOriginKind::AdjustmentType,
3168 self.apply_adjustments(expr, vec![Adjustment {
3169 kind: Adjust::NeverToAny,
3175 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3176 let expr = match &expr.node {
3177 ExprKind::DropTemps(expr) => expr,
3180 // Error possibly reported in `check_assign` so avoid emitting error again.
3181 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3186 fn check_expr_coercable_to_type(&self,
3187 expr: &'gcx hir::Expr,
3188 expected: Ty<'tcx>) -> Ty<'tcx> {
3189 let ty = self.check_expr_with_hint(expr, expected);
3190 // checks don't need two phase
3191 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3194 fn check_expr_with_hint(&self,
3195 expr: &'gcx hir::Expr,
3196 expected: Ty<'tcx>) -> Ty<'tcx> {
3197 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3200 fn check_expr_with_expectation(&self,
3201 expr: &'gcx hir::Expr,
3202 expected: Expectation<'tcx>) -> Ty<'tcx> {
3203 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3206 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3207 self.check_expr_with_expectation(expr, NoExpectation)
3210 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3211 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3214 // Determine the `Self` type, using fresh variables for all variables
3215 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3216 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3218 pub fn impl_self_ty(&self,
3219 span: Span, // (potential) receiver for this impl
3221 -> TypeAndSubsts<'tcx> {
3222 let ity = self.tcx.type_of(did);
3223 debug!("impl_self_ty: ity={:?}", ity);
3225 let substs = self.fresh_substs_for_item(span, did);
3226 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3228 TypeAndSubsts { substs: substs, ty: substd_ty }
3231 /// Unifies the output type with the expected type early, for more coercions
3232 /// and forward type information on the input expressions.
3233 fn expected_inputs_for_expected_output(&self,
3235 expected_ret: Expectation<'tcx>,
3236 formal_ret: Ty<'tcx>,
3237 formal_args: &[Ty<'tcx>])
3239 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3240 let ret_ty = match expected_ret.only_has_type(self) {
3242 None => return Vec::new()
3244 let expect_args = self.fudge_inference_if_ok(|| {
3245 // Attempt to apply a subtyping relationship between the formal
3246 // return type (likely containing type variables if the function
3247 // is polymorphic) and the expected return type.
3248 // No argument expectations are produced if unification fails.
3249 let origin = self.misc(call_span);
3250 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3252 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3253 // to identity so the resulting type is not constrained.
3256 // Process any obligations locally as much as
3257 // we can. We don't care if some things turn
3258 // out unconstrained or ambiguous, as we're
3259 // just trying to get hints here.
3260 self.save_and_restore_in_snapshot_flag(|_| {
3261 let mut fulfill = TraitEngine::new(self.tcx);
3262 for obligation in ok.obligations {
3263 fulfill.register_predicate_obligation(self, obligation);
3265 fulfill.select_where_possible(self)
3266 }).map_err(|_| ())?;
3268 Err(_) => return Err(()),
3271 // Record all the argument types, with the substitutions
3272 // produced from the above subtyping unification.
3273 Ok(formal_args.iter().map(|ty| {
3274 self.resolve_vars_if_possible(ty)
3276 }).unwrap_or_default();
3277 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3278 formal_args, formal_ret,
3279 expect_args, expected_ret);
3283 // Checks a method call.
3284 fn check_method_call(&self,
3285 expr: &'gcx hir::Expr,
3286 segment: &hir::PathSegment,
3288 args: &'gcx [hir::Expr],
3289 expected: Expectation<'tcx>,
3290 needs: Needs) -> Ty<'tcx> {
3291 let rcvr = &args[0];
3292 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3293 // no need to check for bot/err -- callee does that
3294 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3296 let method = match self.lookup_method(rcvr_t,
3302 self.write_method_call(expr.hir_id, method);
3306 if segment.ident.name != kw::Invalid {
3307 self.report_method_error(span,
3310 SelfSource::MethodCall(rcvr),
3318 // Call the generic checker.
3319 self.check_method_argument_types(span,
3327 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3331 .unwrap_or_else(|| span_bug!(return_expr.span,
3332 "check_return_expr called outside fn body"));
3334 let ret_ty = ret_coercion.borrow().expected_ty();
3335 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3336 ret_coercion.borrow_mut()
3338 &self.cause(return_expr.span,
3339 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3344 // Check field access expressions
3345 fn check_field(&self,
3346 expr: &'gcx hir::Expr,
3348 base: &'gcx hir::Expr,
3349 field: ast::Ident) -> Ty<'tcx> {
3350 let expr_t = self.check_expr_with_needs(base, needs);
3351 let expr_t = self.structurally_resolved_type(base.span,
3353 let mut private_candidate = None;
3354 let mut autoderef = self.autoderef(expr.span, expr_t);
3355 while let Some((base_t, _)) = autoderef.next() {
3357 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3358 debug!("struct named {:?}", base_t);
3359 let (ident, def_scope) =
3360 self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
3361 let fields = &base_def.non_enum_variant().fields;
3362 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3363 let field = &fields[index];
3364 let field_ty = self.field_ty(expr.span, field, substs);
3365 // Save the index of all fields regardless of their visibility in case
3366 // of error recovery.
3367 self.write_field_index(expr.hir_id, index);
3368 if field.vis.is_accessible_from(def_scope, self.tcx) {
3369 let adjustments = autoderef.adjust_steps(self, needs);
3370 self.apply_adjustments(base, adjustments);
3371 autoderef.finalize(self);
3373 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3376 private_candidate = Some((base_def.did, field_ty));
3379 ty::Tuple(ref tys) => {
3380 let fstr = field.as_str();
3381 if let Ok(index) = fstr.parse::<usize>() {
3382 if fstr == index.to_string() {
3383 if let Some(field_ty) = tys.get(index) {
3384 let adjustments = autoderef.adjust_steps(self, needs);
3385 self.apply_adjustments(base, adjustments);
3386 autoderef.finalize(self);
3388 self.write_field_index(expr.hir_id, index);
3389 return field_ty.expect_ty();
3397 autoderef.unambiguous_final_ty(self);
3399 if let Some((did, field_ty)) = private_candidate {
3400 let struct_path = self.tcx().def_path_str(did);
3401 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3402 "field `{}` of struct `{}` is private",
3403 field, struct_path);
3404 // Also check if an accessible method exists, which is often what is meant.
3405 if self.method_exists(field, expr_t, expr.hir_id, false)
3406 && !self.expr_in_place(expr.hir_id)
3408 self.suggest_method_call(
3410 &format!("a method `{}` also exists, call it with parentheses", field),
3418 } else if field.name == kw::Invalid {
3419 self.tcx().types.err
3420 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3421 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3422 "attempted to take value of method `{}` on type `{}`",
3425 if !self.expr_in_place(expr.hir_id) {
3426 self.suggest_method_call(
3428 "use parentheses to call the method",
3434 err.help("methods are immutable and cannot be assigned to");
3438 self.tcx().types.err
3440 if !expr_t.is_primitive_ty() {
3441 let mut err = self.no_such_field_err(field.span, field, expr_t);
3444 ty::Adt(def, _) if !def.is_enum() => {
3445 if let Some(suggested_field_name) =
3446 Self::suggest_field_name(def.non_enum_variant(),
3447 &field.as_str(), vec![]) {
3448 err.span_suggestion(
3450 "a field with a similar name exists",
3451 suggested_field_name.to_string(),
3452 Applicability::MaybeIncorrect,
3455 err.span_label(field.span, "unknown field");
3456 let struct_variant_def = def.non_enum_variant();
3457 let field_names = self.available_field_names(struct_variant_def);
3458 if !field_names.is_empty() {
3459 err.note(&format!("available fields are: {}",
3460 self.name_series_display(field_names)));
3464 ty::Array(_, len) => {
3465 if let (Some(len), Ok(user_index)) = (
3466 len.assert_usize(self.tcx),
3467 field.as_str().parse::<u64>()
3469 let base = self.tcx.sess.source_map()
3470 .span_to_snippet(base.span)
3472 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3473 let help = "instead of using tuple indexing, use array indexing";
3474 let suggestion = format!("{}[{}]", base, field);
3475 let applicability = if len < user_index {
3476 Applicability::MachineApplicable
3478 Applicability::MaybeIncorrect
3480 err.span_suggestion(
3481 expr.span, help, suggestion, applicability
3486 let base = self.tcx.sess.source_map()
3487 .span_to_snippet(base.span)
3488 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3489 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3490 let suggestion = format!("(*{}).{}", base, field);
3491 err.span_suggestion(
3495 Applicability::MaybeIncorrect,
3502 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3503 "`{}` is a primitive type and therefore doesn't have fields",
3506 self.tcx().types.err
3510 // Return an hint about the closest match in field names
3511 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3513 skip: Vec<LocalInternedString>)
3515 let names = variant.fields.iter().filter_map(|field| {
3516 // ignore already set fields and private fields from non-local crates
3517 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3518 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3522 Some(&field.ident.name)
3526 find_best_match_for_name(names, field, None)
3529 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3530 variant.fields.iter().filter(|field| {
3532 self.tcx.adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id).1;
3533 field.vis.is_accessible_from(def_scope, self.tcx)
3535 .map(|field| field.ident.name)
3539 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3540 // dynamic limit, to never omit just one field
3541 let limit = if names.len() == 6 { 6 } else { 5 };
3542 let mut display = names.iter().take(limit)
3543 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3544 if names.len() > limit {
3545 display = format!("{} ... and {} others", display, names.len() - limit);
3550 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3551 -> DiagnosticBuilder<'_> {
3552 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3553 "no field `{}` on type `{}`",
3557 fn report_unknown_field(
3560 variant: &'tcx ty::VariantDef,
3562 skip_fields: &[hir::Field],
3565 if variant.recovered {
3568 let mut err = self.type_error_struct_with_diag(
3570 |actual| match ty.sty {
3571 ty::Adt(adt, ..) if adt.is_enum() => {
3572 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3573 "{} `{}::{}` has no field named `{}`",
3574 kind_name, actual, variant.ident, field.ident)
3577 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3578 "{} `{}` has no field named `{}`",
3579 kind_name, actual, field.ident)
3583 // prevent all specified fields from being suggested
3584 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3585 if let Some(field_name) = Self::suggest_field_name(variant,
3586 &field.ident.as_str(),
3587 skip_fields.collect()) {
3588 err.span_suggestion(
3590 "a field with a similar name exists",
3591 field_name.to_string(),
3592 Applicability::MaybeIncorrect,
3596 ty::Adt(adt, ..) => {
3598 err.span_label(field.ident.span,
3599 format!("`{}::{}` does not have this field",
3600 ty, variant.ident));
3602 err.span_label(field.ident.span,
3603 format!("`{}` does not have this field", ty));
3605 let available_field_names = self.available_field_names(variant);
3606 if !available_field_names.is_empty() {
3607 err.note(&format!("available fields are: {}",
3608 self.name_series_display(available_field_names)));
3611 _ => bug!("non-ADT passed to report_unknown_field")
3617 fn check_expr_struct_fields(&self,
3619 expected: Expectation<'tcx>,
3620 expr_id: hir::HirId,
3622 variant: &'tcx ty::VariantDef,
3623 ast_fields: &'gcx [hir::Field],
3624 check_completeness: bool) -> bool {
3628 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3629 .get(0).cloned().unwrap_or(adt_ty);
3630 // re-link the regions that EIfEO can erase.
3631 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3633 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3634 &ty::Adt(adt, substs) => {
3635 (substs, adt.adt_kind(), adt.variant_descr())
3637 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3640 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3641 (field.ident.modern(), (i, field))
3642 ).collect::<FxHashMap<_, _>>();
3644 let mut seen_fields = FxHashMap::default();
3646 let mut error_happened = false;
3648 // Type-check each field.
3649 for field in ast_fields {
3650 let ident = tcx.adjust_ident(field.ident, variant.def_id);
3651 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3652 seen_fields.insert(ident, field.span);
3653 self.write_field_index(field.hir_id, i);
3655 // We don't look at stability attributes on
3656 // struct-like enums (yet...), but it's definitely not
3657 // a bug to have constructed one.
3658 if adt_kind != AdtKind::Enum {
3659 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3662 self.field_ty(field.span, v_field, substs)
3664 error_happened = true;
3665 if let Some(prev_span) = seen_fields.get(&ident) {
3666 let mut err = struct_span_err!(self.tcx.sess,
3669 "field `{}` specified more than once",
3672 err.span_label(field.ident.span, "used more than once");
3673 err.span_label(*prev_span, format!("first use of `{}`", ident));
3677 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3683 // Make sure to give a type to the field even if there's
3684 // an error, so we can continue type-checking.
3685 self.check_expr_coercable_to_type(&field.expr, field_type);
3688 // Make sure the programmer specified correct number of fields.
3689 if kind_name == "union" {
3690 if ast_fields.len() != 1 {
3691 tcx.sess.span_err(span, "union expressions should have exactly one field");
3693 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3694 let len = remaining_fields.len();
3696 let mut displayable_field_names = remaining_fields
3698 .map(|ident| ident.as_str())
3699 .collect::<Vec<_>>();
3701 displayable_field_names.sort();
3703 let truncated_fields_error = if len <= 3 {
3706 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3709 let remaining_fields_names = displayable_field_names.iter().take(3)
3710 .map(|n| format!("`{}`", n))
3711 .collect::<Vec<_>>()
3714 struct_span_err!(tcx.sess, span, E0063,
3715 "missing field{} {}{} in initializer of `{}`",
3716 if remaining_fields.len() == 1 { "" } else { "s" },
3717 remaining_fields_names,
3718 truncated_fields_error,
3720 .span_label(span, format!("missing {}{}",
3721 remaining_fields_names,
3722 truncated_fields_error))
3728 fn check_struct_fields_on_error(&self,
3729 fields: &'gcx [hir::Field],
3730 base_expr: &'gcx Option<P<hir::Expr>>) {
3731 for field in fields {
3732 self.check_expr(&field.expr);
3734 if let Some(ref base) = *base_expr {
3735 self.check_expr(&base);
3739 pub fn check_struct_path(&self,
3742 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3743 let path_span = match *qpath {
3744 QPath::Resolved(_, ref path) => path.span,
3745 QPath::TypeRelative(ref qself, _) => qself.span
3747 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3748 let variant = match def {
3750 self.set_tainted_by_errors();
3753 Res::Def(DefKind::Variant, _) => {
3755 ty::Adt(adt, substs) => {
3756 Some((adt.variant_of_res(def), adt.did, substs))
3758 _ => bug!("unexpected type: {:?}", ty)
3761 Res::Def(DefKind::Struct, _)
3762 | Res::Def(DefKind::Union, _)
3763 | Res::Def(DefKind::TyAlias, _)
3764 | Res::Def(DefKind::AssocTy, _)
3765 | Res::SelfTy(..) => {
3767 ty::Adt(adt, substs) if !adt.is_enum() => {
3768 Some((adt.non_enum_variant(), adt.did, substs))
3773 _ => bug!("unexpected definition: {:?}", def)
3776 if let Some((variant, did, substs)) = variant {
3777 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3778 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3780 // Check bounds on type arguments used in the path.
3781 let bounds = self.instantiate_bounds(path_span, did, substs);
3782 let cause = traits::ObligationCause::new(path_span, self.body_id,
3783 traits::ItemObligation(did));
3784 self.add_obligations_for_parameters(cause, &bounds);
3788 struct_span_err!(self.tcx.sess, path_span, E0071,
3789 "expected struct, variant or union type, found {}",
3790 ty.sort_string(self.tcx))
3791 .span_label(path_span, "not a struct")
3797 fn check_expr_struct(&self,
3799 expected: Expectation<'tcx>,
3801 fields: &'gcx [hir::Field],
3802 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3804 // Find the relevant variant
3805 let (variant, adt_ty) =
3806 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3809 self.check_struct_fields_on_error(fields, base_expr);
3810 return self.tcx.types.err;
3813 let path_span = match *qpath {
3814 QPath::Resolved(_, ref path) => path.span,
3815 QPath::TypeRelative(ref qself, _) => qself.span
3818 // Prohibit struct expressions when non-exhaustive flag is set.
3819 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3820 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3821 span_err!(self.tcx.sess, expr.span, E0639,
3822 "cannot create non-exhaustive {} using struct expression",
3823 adt.variant_descr());
3826 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3827 variant, fields, base_expr.is_none());
3828 if let &Some(ref base_expr) = base_expr {
3829 // If check_expr_struct_fields hit an error, do not attempt to populate
3830 // the fields with the base_expr. This could cause us to hit errors later
3831 // when certain fields are assumed to exist that in fact do not.
3832 if !error_happened {
3833 self.check_expr_has_type_or_error(base_expr, adt_ty);
3835 ty::Adt(adt, substs) if adt.is_struct() => {
3836 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3837 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3842 .fru_field_types_mut()
3843 .insert(expr.hir_id, fru_field_types);
3846 span_err!(self.tcx.sess, base_expr.span, E0436,
3847 "functional record update syntax requires a struct");
3852 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3858 /// If an expression has any sub-expressions that result in a type error,
3859 /// inspecting that expression's type with `ty.references_error()` will return
3860 /// true. Likewise, if an expression is known to diverge, inspecting its
3861 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3862 /// strict, _|_ can appear in the type of an expression that does not,
3863 /// itself, diverge: for example, fn() -> _|_.)
3864 /// Note that inspecting a type's structure *directly* may expose the fact
3865 /// that there are actually multiple representations for `Error`, so avoid
3866 /// that when err needs to be handled differently.
3867 fn check_expr_with_expectation_and_needs(&self,
3868 expr: &'gcx hir::Expr,
3869 expected: Expectation<'tcx>,
3870 needs: Needs) -> Ty<'tcx> {
3871 debug!(">> type-checking: expr={:?} expected={:?}",
3874 // Warn for expressions after diverging siblings.
3875 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3877 // Hide the outer diverging and has_errors flags.
3878 let old_diverges = self.diverges.get();
3879 let old_has_errors = self.has_errors.get();
3880 self.diverges.set(Diverges::Maybe);
3881 self.has_errors.set(false);
3883 let ty = self.check_expr_kind(expr, expected, needs);
3885 // Warn for non-block expressions with diverging children.
3887 ExprKind::Block(..) |
3888 ExprKind::Loop(..) | ExprKind::While(..) |
3889 ExprKind::Match(..) => {}
3891 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3894 // Any expression that produces a value of type `!` must have diverged
3896 self.diverges.set(self.diverges.get() | Diverges::Always);
3899 // Record the type, which applies it effects.
3900 // We need to do this after the warning above, so that
3901 // we don't warn for the diverging expression itself.
3902 self.write_ty(expr.hir_id, ty);
3904 // Combine the diverging and has_error flags.
3905 self.diverges.set(self.diverges.get() | old_diverges);
3906 self.has_errors.set(self.has_errors.get() | old_has_errors);
3908 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3909 debug!("... {:?}, expected is {:?}", ty, expected);
3916 expr: &'gcx hir::Expr,
3917 expected: Expectation<'tcx>,
3921 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3928 let id = expr.hir_id;
3930 ExprKind::Box(ref subexpr) => {
3931 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3933 ty::Adt(def, _) if def.is_box()
3934 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3938 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3939 tcx.mk_box(referent_ty)
3942 ExprKind::Lit(ref lit) => {
3943 self.check_lit(&lit, expected)
3945 ExprKind::Binary(op, ref lhs, ref rhs) => {
3946 self.check_binop(expr, op, lhs, rhs)
3948 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3949 self.check_binop_assign(expr, op, lhs, rhs)
3951 ExprKind::Unary(unop, ref oprnd) => {
3952 let expected_inner = match unop {
3953 hir::UnNot | hir::UnNeg => {
3960 let needs = match unop {
3961 hir::UnDeref => needs,
3964 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3968 if !oprnd_t.references_error() {
3969 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3972 if let Some(mt) = oprnd_t.builtin_deref(true) {
3974 } else if let Some(ok) = self.try_overloaded_deref(
3975 expr.span, oprnd_t, needs) {
3976 let method = self.register_infer_ok_obligations(ok);
3977 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3978 let mutbl = match mutbl {
3979 hir::MutImmutable => AutoBorrowMutability::Immutable,
3980 hir::MutMutable => AutoBorrowMutability::Mutable {
3981 // (It shouldn't actually matter for unary ops whether
3982 // we enable two-phase borrows or not, since a unary
3983 // op has no additional operands.)
3984 allow_two_phase_borrow: AllowTwoPhase::No,
3987 self.apply_adjustments(oprnd, vec![Adjustment {
3988 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3989 target: method.sig.inputs()[0]
3992 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3993 self.write_method_call(expr.hir_id, method);
3995 let mut err = type_error_struct!(
4000 "type `{}` cannot be dereferenced",
4003 let sp = tcx.sess.source_map().start_point(expr.span);
4004 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
4007 tcx.sess.parse_sess.expr_parentheses_needed(
4014 oprnd_t = tcx.types.err;
4018 let result = self.check_user_unop(expr, oprnd_t, unop);
4019 // If it's builtin, we can reuse the type, this helps inference.
4020 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4025 let result = self.check_user_unop(expr, oprnd_t, unop);
4026 // If it's builtin, we can reuse the type, this helps inference.
4027 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4035 ExprKind::AddrOf(mutbl, ref oprnd) => {
4036 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4038 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4039 if oprnd.is_place_expr() {
4040 // Places may legitimately have unsized types.
4041 // For example, dereferences of a fat pointer and
4042 // the last field of a struct can be unsized.
4045 Expectation::rvalue_hint(self, ty)
4051 let needs = Needs::maybe_mut_place(mutbl);
4052 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4054 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4055 if tm.ty.references_error() {
4058 // Note: at this point, we cannot say what the best lifetime
4059 // is to use for resulting pointer. We want to use the
4060 // shortest lifetime possible so as to avoid spurious borrowck
4061 // errors. Moreover, the longest lifetime will depend on the
4062 // precise details of the value whose address is being taken
4063 // (and how long it is valid), which we don't know yet until type
4064 // inference is complete.
4066 // Therefore, here we simply generate a region variable. The
4067 // region inferencer will then select the ultimate value.
4068 // Finally, borrowck is charged with guaranteeing that the
4069 // value whose address was taken can actually be made to live
4070 // as long as it needs to live.
4071 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4072 tcx.mk_ref(region, tm)
4075 ExprKind::Path(ref qpath) => {
4076 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4078 let ty = match res {
4080 self.set_tainted_by_errors();
4083 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4084 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4087 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4090 if let ty::FnDef(..) = ty.sty {
4091 let fn_sig = ty.fn_sig(tcx);
4092 if !tcx.features().unsized_locals {
4093 // We want to remove some Sized bounds from std functions,
4094 // but don't want to expose the removal to stable Rust.
4095 // i.e., we don't want to allow
4101 // to work in stable even if the Sized bound on `drop` is relaxed.
4102 for i in 0..fn_sig.inputs().skip_binder().len() {
4103 // We just want to check sizedness, so instead of introducing
4104 // placeholder lifetimes with probing, we just replace higher lifetimes
4106 let input = self.replace_bound_vars_with_fresh_vars(
4108 infer::LateBoundRegionConversionTime::FnCall,
4109 &fn_sig.input(i)).0;
4110 self.require_type_is_sized_deferred(input, expr.span,
4111 traits::SizedArgumentType);
4114 // Here we want to prevent struct constructors from returning unsized types.
4115 // There were two cases this happened: fn pointer coercion in stable
4116 // and usual function call in presense of unsized_locals.
4117 // Also, as we just want to check sizedness, instead of introducing
4118 // placeholder lifetimes with probing, we just replace higher lifetimes
4120 let output = self.replace_bound_vars_with_fresh_vars(
4122 infer::LateBoundRegionConversionTime::FnCall,
4123 &fn_sig.output()).0;
4124 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4127 // We always require that the type provided as the value for
4128 // a type parameter outlives the moment of instantiation.
4129 let substs = self.tables.borrow().node_substs(expr.hir_id);
4130 self.add_wf_bounds(substs, expr);
4134 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4135 for expr in outputs.iter().chain(inputs.iter()) {
4136 self.check_expr(expr);
4140 ExprKind::Break(destination, ref expr_opt) => {
4141 if let Ok(target_id) = destination.target_id {
4143 if let Some(ref e) = *expr_opt {
4144 // If this is a break with a value, we need to type-check
4145 // the expression. Get an expected type from the loop context.
4146 let opt_coerce_to = {
4147 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4148 enclosing_breakables.find_breakable(target_id)
4151 .map(|coerce| coerce.expected_ty())
4154 // If the loop context is not a `loop { }`, then break with
4155 // a value is illegal, and `opt_coerce_to` will be `None`.
4156 // Just set expectation to error in that case.
4157 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4159 // Recurse without `enclosing_breakables` borrowed.
4160 e_ty = self.check_expr_with_hint(e, coerce_to);
4161 cause = self.misc(e.span);
4163 // Otherwise, this is a break *without* a value. That's
4164 // always legal, and is equivalent to `break ()`.
4165 e_ty = tcx.mk_unit();
4166 cause = self.misc(expr.span);
4169 // Now that we have type-checked `expr_opt`, borrow
4170 // the `enclosing_loops` field and let's coerce the
4171 // type of `expr_opt` into what is expected.
4172 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4173 let ctxt = enclosing_breakables.find_breakable(target_id);
4174 if let Some(ref mut coerce) = ctxt.coerce {
4175 if let Some(ref e) = *expr_opt {
4176 coerce.coerce(self, &cause, e, e_ty);
4178 assert!(e_ty.is_unit());
4179 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4182 // If `ctxt.coerce` is `None`, we can just ignore
4183 // the type of the expresison. This is because
4184 // either this was a break *without* a value, in
4185 // which case it is always a legal type (`()`), or
4186 // else an error would have been flagged by the
4187 // `loops` pass for using break with an expression
4188 // where you are not supposed to.
4189 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4192 ctxt.may_break = true;
4194 // the type of a `break` is always `!`, since it diverges
4197 // Otherwise, we failed to find the enclosing loop;
4198 // this can only happen if the `break` was not
4199 // inside a loop at all, which is caught by the
4200 // loop-checking pass.
4201 if self.tcx.sess.err_count() == 0 {
4202 self.tcx.sess.delay_span_bug(expr.span,
4203 "break was outside loop, but no error was emitted");
4206 // We still need to assign a type to the inner expression to
4207 // prevent the ICE in #43162.
4208 if let Some(ref e) = *expr_opt {
4209 self.check_expr_with_hint(e, tcx.types.err);
4211 // ... except when we try to 'break rust;'.
4212 // ICE this expression in particular (see #43162).
4213 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4214 if path.segments.len() == 1 &&
4215 path.segments[0].ident.name == sym::rust {
4216 fatally_break_rust(self.tcx.sess);
4220 // There was an error; make type-check fail.
4225 ExprKind::Continue(destination) => {
4226 if destination.target_id.is_ok() {
4229 // There was an error; make type-check fail.
4233 ExprKind::Ret(ref expr_opt) => {
4234 if self.ret_coercion.is_none() {
4235 struct_span_err!(self.tcx.sess, expr.span, E0572,
4236 "return statement outside of function body").emit();
4237 } else if let Some(ref e) = *expr_opt {
4238 if self.ret_coercion_span.borrow().is_none() {
4239 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4241 self.check_return_expr(e);
4243 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4244 if self.ret_coercion_span.borrow().is_none() {
4245 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4247 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4248 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4249 coercion.coerce_forced_unit(
4254 fn_decl.output.span(),
4256 "expected `{}` because of this return type",
4264 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4269 ExprKind::Assign(ref lhs, ref rhs) => {
4270 self.check_assign(expr, expected, lhs, rhs)
4272 ExprKind::While(ref cond, ref body, _) => {
4273 let ctxt = BreakableCtxt {
4274 // cannot use break with a value from a while loop
4276 may_break: false, // Will get updated if/when we find a `break`.
4279 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4280 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4281 let cond_diverging = self.diverges.get();
4282 self.check_block_no_value(&body);
4284 // We may never reach the body so it diverging means nothing.
4285 self.diverges.set(cond_diverging);
4289 // No way to know whether it's diverging because
4290 // of a `break` or an outer `break` or `return`.
4291 self.diverges.set(Diverges::Maybe);
4296 ExprKind::Loop(ref body, _, source) => {
4297 let coerce = match source {
4298 // you can only use break with a value from a normal `loop { }`
4299 hir::LoopSource::Loop => {
4300 let coerce_to = expected.coercion_target_type(self, body.span);
4301 Some(CoerceMany::new(coerce_to))
4304 hir::LoopSource::WhileLet |
4305 hir::LoopSource::ForLoop => {
4310 let ctxt = BreakableCtxt {
4312 may_break: false, // Will get updated if/when we find a `break`.
4315 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4316 self.check_block_no_value(&body);
4320 // No way to know whether it's diverging because
4321 // of a `break` or an outer `break` or `return`.
4322 self.diverges.set(Diverges::Maybe);
4325 // If we permit break with a value, then result type is
4326 // the LUB of the breaks (possibly ! if none); else, it
4327 // is nil. This makes sense because infinite loops
4328 // (which would have type !) are only possible iff we
4329 // permit break with a value [1].
4330 if ctxt.coerce.is_none() && !ctxt.may_break {
4332 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4334 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4336 ExprKind::Match(ref discrim, ref arms, match_src) => {
4337 self.check_match(expr, &discrim, arms, expected, match_src)
4339 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4340 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4342 ExprKind::Block(ref body, _) => {
4343 self.check_block_with_expected(&body, expected)
4345 ExprKind::Call(ref callee, ref args) => {
4346 self.check_call(expr, &callee, args, expected)
4348 ExprKind::MethodCall(ref segment, span, ref args) => {
4349 self.check_method_call(expr, segment, span, args, expected, needs)
4351 ExprKind::Cast(ref e, ref t) => {
4352 // Find the type of `e`. Supply hints based on the type we are casting to,
4354 let t_cast = self.to_ty_saving_user_provided_ty(t);
4355 let t_cast = self.resolve_vars_if_possible(&t_cast);
4356 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4357 let t_cast = self.resolve_vars_if_possible(&t_cast);
4359 // Eagerly check for some obvious errors.
4360 if t_expr.references_error() || t_cast.references_error() {
4363 // Defer other checks until we're done type checking.
4364 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4365 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4367 deferred_cast_checks.push(cast_check);
4370 Err(ErrorReported) => {
4376 ExprKind::Type(ref e, ref t) => {
4377 let ty = self.to_ty_saving_user_provided_ty(&t);
4378 self.check_expr_eq_type(&e, ty);
4381 ExprKind::DropTemps(ref e) => {
4382 self.check_expr_with_expectation(e, expected)
4384 ExprKind::Array(ref args) => {
4385 let uty = expected.to_option(self).and_then(|uty| {
4387 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4392 let element_ty = if !args.is_empty() {
4393 let coerce_to = uty.unwrap_or_else(|| {
4394 self.next_ty_var(TypeVariableOrigin {
4395 kind: TypeVariableOriginKind::TypeInference,
4399 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4400 assert_eq!(self.diverges.get(), Diverges::Maybe);
4402 let e_ty = self.check_expr_with_hint(e, coerce_to);
4403 let cause = self.misc(e.span);
4404 coerce.coerce(self, &cause, e, e_ty);
4406 coerce.complete(self)
4408 self.next_ty_var(TypeVariableOrigin {
4409 kind: TypeVariableOriginKind::TypeInference,
4413 tcx.mk_array(element_ty, args.len() as u64)
4415 ExprKind::Repeat(ref element, ref count) => {
4416 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4417 let param_env = ty::ParamEnv::empty();
4418 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4419 let instance = ty::Instance::resolve(
4425 let global_id = GlobalId {
4429 let count = tcx.const_eval(param_env.and(global_id));
4431 let uty = match expected {
4432 ExpectHasType(uty) => {
4434 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4441 let (element_ty, t) = match uty {
4443 self.check_expr_coercable_to_type(&element, uty);
4447 let ty = self.next_ty_var(TypeVariableOrigin {
4448 kind: TypeVariableOriginKind::MiscVariable,
4451 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4456 if let Ok(count) = count {
4457 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4459 // For [foo, ..n] where n > 1, `foo` must have
4461 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4462 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4466 if element_ty.references_error() {
4468 } else if let Ok(count) = count {
4469 tcx.mk_ty(ty::Array(t, count))
4474 ExprKind::Tup(ref elts) => {
4475 let flds = expected.only_has_type(self).and_then(|ty| {
4476 let ty = self.resolve_type_vars_with_obligations(ty);
4478 ty::Tuple(ref flds) => Some(&flds[..]),
4483 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4484 let t = match flds {
4485 Some(ref fs) if i < fs.len() => {
4486 let ety = fs[i].expect_ty();
4487 self.check_expr_coercable_to_type(&e, ety);
4491 self.check_expr_with_expectation(&e, NoExpectation)
4496 let tuple = tcx.mk_tup(elt_ts_iter);
4497 if tuple.references_error() {
4500 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4504 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4505 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4507 ExprKind::Field(ref base, field) => {
4508 self.check_field(expr, needs, &base, field)
4510 ExprKind::Index(ref base, ref idx) => {
4511 let base_t = self.check_expr_with_needs(&base, needs);
4512 let idx_t = self.check_expr(&idx);
4514 if base_t.references_error() {
4516 } else if idx_t.references_error() {
4519 let base_t = self.structurally_resolved_type(base.span, base_t);
4520 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4521 Some((index_ty, element_ty)) => {
4522 // two-phase not needed because index_ty is never mutable
4523 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4528 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4529 "cannot index into a value of type `{}`",
4531 // Try to give some advice about indexing tuples.
4532 if let ty::Tuple(..) = base_t.sty {
4533 let mut needs_note = true;
4534 // If the index is an integer, we can show the actual
4535 // fixed expression:
4536 if let ExprKind::Lit(ref lit) = idx.node {
4537 if let ast::LitKind::Int(i,
4538 ast::LitIntType::Unsuffixed) = lit.node {
4539 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4540 if let Ok(snip) = snip {
4541 err.span_suggestion(
4543 "to access tuple elements, use",
4544 format!("{}.{}", snip, i),
4545 Applicability::MachineApplicable,
4552 err.help("to access tuple elements, use tuple indexing \
4553 syntax (e.g., `tuple.0`)");
4562 ExprKind::Yield(ref value) => {
4563 match self.yield_ty {
4565 self.check_expr_coercable_to_type(&value, ty);
4568 struct_span_err!(self.tcx.sess, expr.span, E0627,
4569 "yield statement outside of generator literal").emit();
4574 hir::ExprKind::Err => {
4580 /// Type check assignment expression `expr` of form `lhs = rhs`.
4581 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4584 expr: &'gcx hir::Expr,
4585 expected: Expectation<'tcx>,
4586 lhs: &'gcx hir::Expr,
4587 rhs: &'gcx hir::Expr,
4589 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4590 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4592 let expected_ty = expected.coercion_target_type(self, expr.span);
4593 if expected_ty == self.tcx.types.bool {
4594 // The expected type is `bool` but this will result in `()` so we can reasonably
4595 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4596 // The likely cause of this is `if foo = bar { .. }`.
4597 let actual_ty = self.tcx.mk_unit();
4598 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4599 let msg = "try comparing for equality";
4600 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4601 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4602 if let (Ok(left), Ok(right)) = (left, right) {
4603 let help = format!("{} == {}", left, right);
4604 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4609 } else if !lhs.is_place_expr() {
4610 struct_span_err!(self.tcx.sess, expr.span, E0070,
4611 "invalid left-hand side expression")
4612 .span_label(expr.span, "left-hand of expression not valid")
4616 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4618 if lhs_ty.references_error() || rhs_ty.references_error() {
4625 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4626 // The newly resolved definition is written into `type_dependent_defs`.
4627 fn finish_resolving_struct_path(&self,
4634 QPath::Resolved(ref maybe_qself, ref path) => {
4635 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4636 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4639 QPath::TypeRelative(ref qself, ref segment) => {
4640 let ty = self.to_ty(qself);
4642 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4647 let result = AstConv::associated_path_to_ty(
4656 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4657 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4659 // Write back the new resolution.
4660 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4662 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4667 /// Resolves associated value path into a base type and associated constant or method
4668 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4669 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4673 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4675 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4676 let (ty, qself, item_segment) = match *qpath {
4677 QPath::Resolved(ref opt_qself, ref path) => {
4679 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4680 &path.segments[..]);
4682 QPath::TypeRelative(ref qself, ref segment) => {
4683 (self.to_ty(qself), qself, segment)
4686 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4687 // Return directly on cache hit. This is useful to avoid doubly reporting
4688 // errors with default match binding modes. See #44614.
4689 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4690 .unwrap_or(Res::Err);
4691 return (def, Some(ty), slice::from_ref(&**item_segment));
4693 let item_name = item_segment.ident;
4694 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4695 let result = match error {
4696 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4697 _ => Err(ErrorReported),
4699 if item_name.name != kw::Invalid {
4700 self.report_method_error(
4704 SelfSource::QPath(qself),
4712 // Write back the new resolution.
4713 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4715 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4717 slice::from_ref(&**item_segment),
4721 pub fn check_decl_initializer(&self,
4722 local: &'gcx hir::Local,
4723 init: &'gcx hir::Expr) -> Ty<'tcx>
4725 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4726 // for #42640 (default match binding modes).
4729 let ref_bindings = local.pat.contains_explicit_ref_binding();
4731 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4732 if let Some(m) = ref_bindings {
4733 // Somewhat subtle: if we have a `ref` binding in the pattern,
4734 // we want to avoid introducing coercions for the RHS. This is
4735 // both because it helps preserve sanity and, in the case of
4736 // ref mut, for soundness (issue #23116). In particular, in
4737 // the latter case, we need to be clear that the type of the
4738 // referent for the reference that results is *equal to* the
4739 // type of the place it is referencing, and not some
4740 // supertype thereof.
4741 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4742 self.demand_eqtype(init.span, local_ty, init_ty);
4745 self.check_expr_coercable_to_type(init, local_ty)
4749 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4750 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4751 self.write_ty(local.hir_id, t);
4753 if let Some(ref init) = local.init {
4754 let init_ty = self.check_decl_initializer(local, &init);
4755 if init_ty.references_error() {
4756 self.write_ty(local.hir_id, init_ty);
4760 self.check_pat_walk(
4763 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4766 let pat_ty = self.node_ty(local.pat.hir_id);
4767 if pat_ty.references_error() {
4768 self.write_ty(local.hir_id, pat_ty);
4772 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4773 // Don't do all the complex logic below for `DeclItem`.
4775 hir::StmtKind::Item(..) => return,
4776 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4779 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4781 // Hide the outer diverging and `has_errors` flags.
4782 let old_diverges = self.diverges.get();
4783 let old_has_errors = self.has_errors.get();
4784 self.diverges.set(Diverges::Maybe);
4785 self.has_errors.set(false);
4788 hir::StmtKind::Local(ref l) => {
4789 self.check_decl_local(&l);
4792 hir::StmtKind::Item(_) => {}
4793 hir::StmtKind::Expr(ref expr) => {
4794 // Check with expected type of `()`.
4795 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4797 hir::StmtKind::Semi(ref expr) => {
4798 self.check_expr(&expr);
4802 // Combine the diverging and `has_error` flags.
4803 self.diverges.set(self.diverges.get() | old_diverges);
4804 self.has_errors.set(self.has_errors.get() | old_has_errors);
4807 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4808 let unit = self.tcx.mk_unit();
4809 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4811 // if the block produces a `!` value, that can always be
4812 // (effectively) coerced to unit.
4814 self.demand_suptype(blk.span, unit, ty);
4818 fn check_block_with_expected(&self,
4819 blk: &'gcx hir::Block,
4820 expected: Expectation<'tcx>) -> Ty<'tcx> {
4822 let mut fcx_ps = self.ps.borrow_mut();
4823 let unsafety_state = fcx_ps.recurse(blk);
4824 replace(&mut *fcx_ps, unsafety_state)
4827 // In some cases, blocks have just one exit, but other blocks
4828 // can be targeted by multiple breaks. This can happen both
4829 // with labeled blocks as well as when we desugar
4830 // a `try { ... }` expression.
4834 // 'a: { if true { break 'a Err(()); } Ok(()) }
4836 // Here we would wind up with two coercions, one from
4837 // `Err(())` and the other from the tail expression
4838 // `Ok(())`. If the tail expression is omitted, that's a
4839 // "forced unit" -- unless the block diverges, in which
4840 // case we can ignore the tail expression (e.g., `'a: {
4841 // break 'a 22; }` would not force the type of the block
4843 let tail_expr = blk.expr.as_ref();
4844 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4845 let coerce = if blk.targeted_by_break {
4846 CoerceMany::new(coerce_to_ty)
4848 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4849 Some(e) => slice::from_ref(e),
4852 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4855 let prev_diverges = self.diverges.get();
4856 let ctxt = BreakableCtxt {
4857 coerce: Some(coerce),
4861 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4862 for s in &blk.stmts {
4866 // check the tail expression **without** holding the
4867 // `enclosing_breakables` lock below.
4868 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4870 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4871 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4872 let coerce = ctxt.coerce.as_mut().unwrap();
4873 if let Some(tail_expr_ty) = tail_expr_ty {
4874 let tail_expr = tail_expr.unwrap();
4875 let cause = self.cause(tail_expr.span,
4876 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4882 // Subtle: if there is no explicit tail expression,
4883 // that is typically equivalent to a tail expression
4884 // of `()` -- except if the block diverges. In that
4885 // case, there is no value supplied from the tail
4886 // expression (assuming there are no other breaks,
4887 // this implies that the type of the block will be
4890 // #41425 -- label the implicit `()` as being the
4891 // "found type" here, rather than the "expected type".
4892 if !self.diverges.get().always() {
4893 // #50009 -- Do not point at the entire fn block span, point at the return type
4894 // span, as it is the cause of the requirement, and
4895 // `consider_hint_about_removing_semicolon` will point at the last expression
4896 // if it were a relevant part of the error. This improves usability in editors
4897 // that highlight errors inline.
4898 let mut sp = blk.span;
4899 let mut fn_span = None;
4900 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4901 let ret_sp = decl.output.span();
4902 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4903 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4904 // output would otherwise be incorrect and even misleading. Make sure
4905 // the span we're aiming at correspond to a `fn` body.
4906 if block_sp == blk.span {
4908 fn_span = Some(ident.span);
4912 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4913 if let Some(expected_ty) = expected.only_has_type(self) {
4914 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4916 if let Some(fn_span) = fn_span {
4917 err.span_label(fn_span, "this function's body doesn't return");
4925 // If we can break from the block, then the block's exit is always reachable
4926 // (... as long as the entry is reachable) - regardless of the tail of the block.
4927 self.diverges.set(prev_diverges);
4930 let mut ty = ctxt.coerce.unwrap().complete(self);
4932 if self.has_errors.get() || ty.references_error() {
4933 ty = self.tcx.types.err
4936 self.write_ty(blk.hir_id, ty);
4938 *self.ps.borrow_mut() = prev;
4942 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4943 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4945 Node::Item(&hir::Item {
4946 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4948 Node::ImplItem(&hir::ImplItem {
4949 node: hir::ImplItemKind::Method(_, body_id), ..
4951 let body = self.tcx.hir().body(body_id);
4952 if let ExprKind::Block(block, _) = &body.value.node {
4953 return Some(block.span);
4961 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4962 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4963 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4964 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4967 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4968 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4970 Node::Item(&hir::Item {
4971 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4972 }) => decl.clone().and_then(|decl| {
4973 // This is less than ideal, it will not suggest a return type span on any
4974 // method called `main`, regardless of whether it is actually the entry point,
4975 // but it will still present it as the reason for the expected type.
4976 Some((decl, ident, ident.name != sym::main))
4978 Node::TraitItem(&hir::TraitItem {
4979 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4982 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
4983 Node::ImplItem(&hir::ImplItem {
4984 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4987 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
4992 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4993 /// suggestion can be made, `None` otherwise.
4994 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
4995 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4996 // `while` before reaching it, as block tail returns are not available in them.
4997 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4998 let parent = self.tcx.hir().get_by_hir_id(blk_id);
4999 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5003 /// On implicit return expressions with mismatched types, provides the following suggestions:
5005 /// - Points out the method's return type as the reason for the expected type.
5006 /// - Possible missing semicolon.
5007 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5008 pub fn suggest_mismatched_types_on_tail(
5010 err: &mut DiagnosticBuilder<'tcx>,
5011 expression: &'gcx hir::Expr,
5017 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5018 let mut pointing_at_return_type = false;
5019 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5020 pointing_at_return_type = self.suggest_missing_return_type(
5021 err, &fn_decl, expected, found, can_suggest);
5023 self.suggest_ref_or_into(err, expression, expected, found);
5024 pointing_at_return_type
5027 pub fn suggest_ref_or_into(
5029 err: &mut DiagnosticBuilder<'tcx>,
5034 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5035 err.span_suggestion(
5039 Applicability::MachineApplicable,
5041 } else if !self.check_for_cast(err, expr, found, expected) {
5042 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5046 let methods = self.get_conversion_methods(expr.span, expected, found);
5047 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5048 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5049 .filter_map(|(receiver, method)| {
5050 let method_call = format!(".{}()", method.ident);
5051 if receiver.ends_with(&method_call) {
5052 None // do not suggest code that is already there (#53348)
5054 let method_call_list = [".to_vec()", ".to_string()"];
5055 let sugg = if receiver.ends_with(".clone()")
5056 && method_call_list.contains(&method_call.as_str()) {
5057 let max_len = receiver.rfind(".").unwrap();
5058 format!("{}{}", &receiver[..max_len], method_call)
5060 format!("{}{}", receiver, method_call)
5062 Some(if is_struct_pat_shorthand_field {
5063 format!("{}: {}", receiver, sugg)
5069 if suggestions.peek().is_some() {
5070 err.span_suggestions(
5072 "try using a conversion method",
5074 Applicability::MaybeIncorrect,
5081 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5085 /// bar_that_returns_u32()
5089 /// This routine checks if the return expression in a block would make sense on its own as a
5090 /// statement and the return type has been left as default or has been specified as `()`. If so,
5091 /// it suggests adding a semicolon.
5092 fn suggest_missing_semicolon(&self,
5093 err: &mut DiagnosticBuilder<'tcx>,
5094 expression: &'gcx hir::Expr,
5097 if expected.is_unit() {
5098 // `BlockTailExpression` only relevant if the tail expr would be
5099 // useful on its own.
5100 match expression.node {
5101 ExprKind::Call(..) |
5102 ExprKind::MethodCall(..) |
5103 ExprKind::While(..) |
5104 ExprKind::Loop(..) |
5105 ExprKind::Match(..) |
5106 ExprKind::Block(..) => {
5107 let sp = self.tcx.sess.source_map().next_point(cause_span);
5108 err.span_suggestion(
5110 "try adding a semicolon",
5112 Applicability::MachineApplicable);
5119 /// A possible error is to forget to add a return type that is needed:
5123 /// bar_that_returns_u32()
5127 /// This routine checks if the return type is left as default, the method is not part of an
5128 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5130 fn suggest_missing_return_type(
5132 err: &mut DiagnosticBuilder<'tcx>,
5133 fn_decl: &hir::FnDecl,
5138 // Only suggest changing the return type for methods that
5139 // haven't set a return type at all (and aren't `fn main()` or an impl).
5140 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5141 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5142 err.span_suggestion(
5144 "try adding a return type",
5145 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5146 Applicability::MachineApplicable);
5149 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5150 err.span_label(span, "possibly return type missing here?");
5153 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5154 // `fn main()` must return `()`, do not suggest changing return type
5155 err.span_label(span, "expected `()` because of default return type");
5158 // expectation was caused by something else, not the default return
5159 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5160 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5161 // Only point to return type if the expected type is the return type, as if they
5162 // are not, the expectation must have been caused by something else.
5163 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5165 let ty = AstConv::ast_ty_to_ty(self, ty);
5166 debug!("suggest_missing_return_type: return type {:?}", ty);
5167 debug!("suggest_missing_return_type: expected type {:?}", ty);
5168 if ty.sty == expected.sty {
5169 err.span_label(sp, format!("expected `{}` because of return type",
5178 /// A common error is to add an extra semicolon:
5181 /// fn foo() -> usize {
5186 /// This routine checks if the final statement in a block is an
5187 /// expression with an explicit semicolon whose type is compatible
5188 /// with `expected_ty`. If so, it suggests removing the semicolon.
5189 fn consider_hint_about_removing_semicolon(
5191 blk: &'gcx hir::Block,
5192 expected_ty: Ty<'tcx>,
5193 err: &mut DiagnosticBuilder<'_>,
5195 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5196 err.span_suggestion(
5198 "consider removing this semicolon",
5200 Applicability::MachineApplicable,
5205 fn could_remove_semicolon(
5207 blk: &'gcx hir::Block,
5208 expected_ty: Ty<'tcx>,
5210 // Be helpful when the user wrote `{... expr;}` and
5211 // taking the `;` off is enough to fix the error.
5212 let last_stmt = blk.stmts.last()?;
5213 let last_expr = match last_stmt.node {
5214 hir::StmtKind::Semi(ref e) => e,
5217 let last_expr_ty = self.node_ty(last_expr.hir_id);
5218 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5221 let original_span = original_sp(last_stmt.span, blk.span);
5222 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5225 // Rewrite `SelfCtor` to `Ctor`
5226 pub fn rewrite_self_ctor(
5230 ) -> Result<Res, ErrorReported> {
5232 if let Res::SelfCtor(impl_def_id) = res {
5233 let ty = self.impl_self_ty(span, impl_def_id).ty;
5234 let adt_def = ty.ty_adt_def();
5237 Some(adt_def) if adt_def.has_ctor() => {
5238 let variant = adt_def.non_enum_variant();
5239 let ctor_def_id = variant.ctor_def_id.unwrap();
5240 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5243 let mut err = tcx.sess.struct_span_err(span,
5244 "the `Self` constructor can only be used with tuple or unit structs");
5245 if let Some(adt_def) = adt_def {
5246 match adt_def.adt_kind() {
5248 err.help("did you mean to use one of the enum's variants?");
5252 err.span_suggestion(
5254 "use curly brackets",
5255 String::from("Self { /* fields */ }"),
5256 Applicability::HasPlaceholders,
5271 // Instantiates the given path, which must refer to an item with the given
5272 // number of type parameters and type.
5273 pub fn instantiate_value_path(&self,
5274 segments: &[hir::PathSegment],
5275 self_ty: Option<Ty<'tcx>>,
5279 -> (Ty<'tcx>, Res) {
5281 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5290 let res = match self.rewrite_self_ctor(res, span) {
5292 Err(ErrorReported) => return (tcx.types.err, res),
5294 let path_segs = match res {
5295 Res::Local(_) => vec![],
5296 Res::Def(kind, def_id) =>
5297 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5298 _ => bug!("instantiate_value_path on {:?}", res),
5301 let mut user_self_ty = None;
5302 let mut is_alias_variant_ctor = false;
5304 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5305 if let Some(self_ty) = self_ty {
5306 let adt_def = self_ty.ty_adt_def().unwrap();
5307 user_self_ty = Some(UserSelfTy {
5308 impl_def_id: adt_def.did,
5311 is_alias_variant_ctor = true;
5314 Res::Def(DefKind::Method, def_id)
5315 | Res::Def(DefKind::AssocConst, def_id) => {
5316 let container = tcx.associated_item(def_id).container;
5317 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5319 ty::TraitContainer(trait_did) => {
5320 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5322 ty::ImplContainer(impl_def_id) => {
5323 if segments.len() == 1 {
5324 // `<T>::assoc` will end up here, and so
5325 // can `T::assoc`. It this came from an
5326 // inherent impl, we need to record the
5327 // `T` for posterity (see `UserSelfTy` for
5329 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5330 user_self_ty = Some(UserSelfTy {
5341 // Now that we have categorized what space the parameters for each
5342 // segment belong to, let's sort out the parameters that the user
5343 // provided (if any) into their appropriate spaces. We'll also report
5344 // errors if type parameters are provided in an inappropriate place.
5346 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5347 let generics_has_err = AstConv::prohibit_generics(
5348 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5349 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5356 if let Res::Local(hid) = res {
5357 let ty = self.local_ty(span, hid).decl_ty;
5358 let ty = self.normalize_associated_types_in(span, &ty);
5359 self.write_ty(hir_id, ty);
5363 if generics_has_err {
5364 // Don't try to infer type parameters when prohibited generic arguments were given.
5365 user_self_ty = None;
5368 // Now we have to compare the types that the user *actually*
5369 // provided against the types that were *expected*. If the user
5370 // did not provide any types, then we want to substitute inference
5371 // variables. If the user provided some types, we may still need
5372 // to add defaults. If the user provided *too many* types, that's
5375 let mut infer_args_for_err = FxHashSet::default();
5376 for &PathSeg(def_id, index) in &path_segs {
5377 let seg = &segments[index];
5378 let generics = tcx.generics_of(def_id);
5379 // Argument-position `impl Trait` is treated as a normal generic
5380 // parameter internally, but we don't allow users to specify the
5381 // parameter's value explicitly, so we have to do some error-
5383 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5388 false, // `is_method_call`
5390 if suppress_errors {
5391 infer_args_for_err.insert(index);
5392 self.set_tainted_by_errors(); // See issue #53251.
5396 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5397 tcx.generics_of(*def_id).has_self
5398 }).unwrap_or(false);
5400 let def_id = res.def_id();
5402 // The things we are substituting into the type should not contain
5403 // escaping late-bound regions, and nor should the base type scheme.
5404 let ty = tcx.type_of(def_id);
5406 let substs = AstConv::create_substs_for_generic_args(
5412 // Provide the generic args, and whether types should be inferred.
5414 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5417 // If we've encountered an `impl Trait`-related error, we're just
5418 // going to infer the arguments for better error messages.
5419 if !infer_args_for_err.contains(&index) {
5420 // Check whether the user has provided generic arguments.
5421 if let Some(ref data) = segments[index].args {
5422 return (Some(data), segments[index].infer_types);
5425 return (None, segments[index].infer_types);
5430 // Provide substitutions for parameters for which (valid) arguments have been provided.
5432 match (¶m.kind, arg) {
5433 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5434 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5436 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5437 self.to_ty(ty).into()
5439 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5440 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5442 _ => unreachable!(),
5445 // Provide substitutions for parameters for which arguments are inferred.
5446 |substs, param, infer_types| {
5448 GenericParamDefKind::Lifetime => {
5449 self.re_infer(span, Some(param)).unwrap().into()
5451 GenericParamDefKind::Type { has_default, .. } => {
5452 if !infer_types && has_default {
5453 // If we have a default, then we it doesn't matter that we're not
5454 // inferring the type arguments: we provide the default where any
5456 let default = tcx.type_of(param.def_id);
5459 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5462 // If no type arguments were provided, we have to infer them.
5463 // This case also occurs as a result of some malformed input, e.g.
5464 // a lifetime argument being given instead of a type parameter.
5465 // Using inference instead of `Error` gives better error messages.
5466 self.var_for_def(span, param)
5469 GenericParamDefKind::Const => {
5470 // FIXME(const_generics:defaults)
5471 // No const parameters were provided, we have to infer them.
5472 self.var_for_def(span, param)
5477 assert!(!substs.has_escaping_bound_vars());
5478 assert!(!ty.has_escaping_bound_vars());
5480 // First, store the "user substs" for later.
5481 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5483 // Add all the obligations that are required, substituting and
5484 // normalized appropriately.
5485 let bounds = self.instantiate_bounds(span, def_id, &substs);
5486 self.add_obligations_for_parameters(
5487 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5490 // Substitute the values for the type parameters into the type of
5491 // the referenced item.
5492 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5494 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5495 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5496 // is inherent, there is no `Self` parameter; instead, the impl needs
5497 // type parameters, which we can infer by unifying the provided `Self`
5498 // with the substituted impl type.
5499 // This also occurs for an enum variant on a type alias.
5500 let ty = tcx.type_of(impl_def_id);
5502 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5503 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5504 Ok(ok) => self.register_infer_ok_obligations(ok),
5506 self.tcx.sess.delay_span_bug(span, &format!(
5507 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5515 self.check_rustc_args_require_const(def_id, hir_id, span);
5517 debug!("instantiate_value_path: type of {:?} is {:?}",
5520 self.write_substs(hir_id, substs);
5522 (ty_substituted, res)
5525 fn check_rustc_args_require_const(&self,
5529 // We're only interested in functions tagged with
5530 // #[rustc_args_required_const], so ignore anything that's not.
5531 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5535 // If our calling expression is indeed the function itself, we're good!
5536 // If not, generate an error that this can only be called directly.
5537 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5538 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5540 if let ExprKind::Call(ref callee, ..) = expr.node {
5541 if callee.hir_id == hir_id {
5547 self.tcx.sess.span_err(span, "this function can only be invoked \
5548 directly, not through a function pointer");
5551 // Resolves `typ` by a single level if `typ` is a type variable.
5552 // If no resolution is possible, then an error is reported.
5553 // Numeric inference variables may be left unresolved.
5554 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5555 let ty = self.resolve_type_vars_with_obligations(ty);
5556 if !ty.is_ty_var() {
5559 if !self.is_tainted_by_errors() {
5560 self.need_type_info_err((**self).body_id, sp, ty)
5561 .note("type must be known at this point")
5564 self.demand_suptype(sp, self.tcx.types.err, ty);
5569 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5570 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5571 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5574 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5575 index = enclosing_breakables.stack.len();
5576 enclosing_breakables.by_id.insert(id, index);
5577 enclosing_breakables.stack.push(ctxt);
5581 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5582 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5583 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5584 enclosing_breakables.stack.pop().expect("missing breakable context")
5589 /// Instantiate a QueryResponse in a probe context, without a
5590 /// good ObligationCause.
5591 fn probe_instantiate_query_response(
5594 original_values: &OriginalQueryValues<'tcx>,
5595 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5596 ) -> InferResult<'tcx, Ty<'tcx>>
5598 self.instantiate_query_response_and_region_obligations(
5599 &traits::ObligationCause::misc(span, self.body_id),
5605 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5606 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5607 let mut contained_in_place = false;
5609 while let hir::Node::Expr(parent_expr) =
5610 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5612 match &parent_expr.node {
5613 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5614 if lhs.hir_id == expr_id {
5615 contained_in_place = true;
5621 expr_id = parent_expr.hir_id;
5628 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5629 generics: &ty::Generics,
5631 let own_counts = generics.own_counts();
5633 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5639 if own_counts.types == 0 {
5643 // Make a vector of booleans initially false, set to true when used.
5644 let mut types_used = vec![false; own_counts.types];
5646 for leaf_ty in ty.walk() {
5647 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5648 debug!("Found use of ty param num {}", index);
5649 types_used[index as usize - own_counts.lifetimes] = true;
5650 } else if let ty::Error = leaf_ty.sty {
5651 // If there is already another error, do not emit
5652 // an error for not using a type Parameter.
5653 assert!(tcx.sess.err_count() > 0);
5658 let types = generics.params.iter().filter(|param| match param.kind {
5659 ty::GenericParamDefKind::Type { .. } => true,
5662 for (&used, param) in types_used.iter().zip(types) {
5664 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5665 let span = tcx.hir().span_by_hir_id(id);
5666 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5667 .span_label(span, "unused type parameter")
5673 fn fatally_break_rust(sess: &Session) {
5674 let handler = sess.diagnostic();
5675 handler.span_bug_no_panic(
5677 "It looks like you're trying to break rust; would you like some ICE?",
5679 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5680 handler.note_without_error(
5681 "we would appreciate a joke overview: \
5682 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5684 handler.note_without_error(&format!("rustc {} running on {}",
5685 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5686 crate::session::config::host_triple(),
5690 fn potentially_plural_count(count: usize, word: &str) -> String {
5691 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })