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_data_structures::sync::Lrc;
101 use rustc_target::spec::abi::Abi;
102 use rustc::infer::opaque_types::OpaqueTypeDecl;
103 use rustc::infer::type_variable::{TypeVariableOrigin};
104 use rustc::middle::region;
105 use rustc::mir::interpret::{ConstValue, GlobalId};
106 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
108 self, AdtKind, CanonicalUserType, Ty, TyCtxt, GenericParamDefKind, Visibility,
109 ToPolyTraitRef, ToPredicate, RegionKind, UserType
111 use rustc::ty::adjustment::{
112 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
114 use rustc::ty::fold::TypeFoldable;
115 use rustc::ty::query::Providers;
116 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
117 use rustc::ty::util::{Representability, IntTypeExt, Discr};
118 use rustc::ty::layout::VariantIdx;
119 use syntax_pos::{self, BytePos, Span, MultiSpan};
120 use syntax_pos::hygiene::CompilerDesugaringKind;
123 use syntax::feature_gate::{GateIssue, emit_feature_err};
125 use syntax::source_map::{DUMMY_SP, original_sp};
126 use syntax::symbol::{Symbol, LocalInternedString, keywords, sym};
127 use syntax::util::lev_distance::find_best_match_for_name;
129 use std::cell::{Cell, RefCell, Ref, RefMut};
130 use std::collections::hash_map::Entry;
132 use std::fmt::Display;
134 use std::mem::replace;
135 use std::ops::{self, Deref};
138 use crate::require_c_abi_if_c_variadic;
139 use crate::session::Session;
140 use crate::session::config::EntryFnType;
141 use crate::TypeAndSubsts;
143 use crate::util::captures::Captures;
144 use crate::util::common::{ErrorReported, indenter};
145 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
147 pub use self::Expectation::*;
148 use self::autoderef::Autoderef;
149 use self::callee::DeferredCallResolution;
150 use self::coercion::{CoerceMany, DynamicCoerceMany};
151 pub use self::compare_method::{compare_impl_method, compare_const_impl};
152 use self::method::{MethodCallee, SelfSource};
153 use self::TupleArgumentsFlag::*;
155 /// The type of a local binding, including the revealed type for anon types.
156 #[derive(Copy, Clone)]
157 pub struct LocalTy<'tcx> {
159 revealed_ty: Ty<'tcx>
162 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
163 #[derive(Copy, Clone)]
164 struct MaybeInProgressTables<'a, 'tcx: 'a> {
165 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
168 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
169 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
178 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
179 match self.maybe_tables {
180 Some(tables) => tables.borrow_mut(),
182 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
188 /// Closures defined within the function. For example:
191 /// bar(move|| { ... })
194 /// Here, the function `foo()` and the closure passed to
195 /// `bar()` will each have their own `FnCtxt`, but they will
196 /// share the inherited fields.
197 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
198 infcx: InferCtxt<'a, 'gcx, 'tcx>,
200 tables: MaybeInProgressTables<'a, 'tcx>,
202 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
204 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
206 // Some additional `Sized` obligations badly affect type inference.
207 // These obligations are added in a later stage of typeck.
208 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
210 // When we process a call like `c()` where `c` is a closure type,
211 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
212 // `FnOnce` closure. In that case, we defer full resolution of the
213 // call until upvar inference can kick in and make the
214 // decision. We keep these deferred resolutions grouped by the
215 // def-id of the closure, so that once we decide, we can easily go
216 // back and process them.
217 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
219 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
221 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
223 // Opaque types found in explicit return types and their
224 // associated fresh inference variable. Writeback resolves these
225 // variables to get the concrete type, which can be used to
226 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
227 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
229 /// Each type parameter has an implicit region bound that
230 /// indicates it must outlive at least the function body (the user
231 /// may specify stronger requirements). This field indicates the
232 /// region of the callee. If it is `None`, then the parameter
233 /// environment is for an item or something where the "callee" is
235 implicit_region_bound: Option<ty::Region<'tcx>>,
237 body_id: Option<hir::BodyId>,
240 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
241 type Target = InferCtxt<'a, 'gcx, 'tcx>;
242 fn deref(&self) -> &Self::Target {
247 /// When type-checking an expression, we propagate downward
248 /// whatever type hint we are able in the form of an `Expectation`.
249 #[derive(Copy, Clone, Debug)]
250 pub enum Expectation<'tcx> {
251 /// We know nothing about what type this expression should have.
254 /// This expression should have the type given (or some subtype).
255 ExpectHasType(Ty<'tcx>),
257 /// This expression will be cast to the `Ty`.
258 ExpectCastableToType(Ty<'tcx>),
260 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
261 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
262 ExpectRvalueLikeUnsized(Ty<'tcx>),
265 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
266 // Disregard "castable to" expectations because they
267 // can lead us astray. Consider for example `if cond
268 // {22} else {c} as u8` -- if we propagate the
269 // "castable to u8" constraint to 22, it will pick the
270 // type 22u8, which is overly constrained (c might not
271 // be a u8). In effect, the problem is that the
272 // "castable to" expectation is not the tightest thing
273 // we can say, so we want to drop it in this case.
274 // The tightest thing we can say is "must unify with
275 // else branch". Note that in the case of a "has type"
276 // constraint, this limitation does not hold.
278 // If the expected type is just a type variable, then don't use
279 // an expected type. Otherwise, we might write parts of the type
280 // when checking the 'then' block which are incompatible with the
282 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
284 ExpectHasType(ety) => {
285 let ety = fcx.shallow_resolve(ety);
286 if !ety.is_ty_var() {
292 ExpectRvalueLikeUnsized(ety) => {
293 ExpectRvalueLikeUnsized(ety)
299 /// Provides an expectation for an rvalue expression given an *optional*
300 /// hint, which is not required for type safety (the resulting type might
301 /// be checked higher up, as is the case with `&expr` and `box expr`), but
302 /// is useful in determining the concrete type.
304 /// The primary use case is where the expected type is a fat pointer,
305 /// like `&[isize]`. For example, consider the following statement:
307 /// let x: &[isize] = &[1, 2, 3];
309 /// In this case, the expected type for the `&[1, 2, 3]` expression is
310 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
311 /// expectation `ExpectHasType([isize])`, that would be too strong --
312 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
313 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
314 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
315 /// which still is useful, because it informs integer literals and the like.
316 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
317 /// for examples of where this comes up,.
318 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
319 match fcx.tcx.struct_tail(ty).sty {
320 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
321 ExpectRvalueLikeUnsized(ty)
323 _ => ExpectHasType(ty)
327 // Resolves `expected` by a single level if it is a variable. If
328 // there is no expected type or resolution is not possible (e.g.,
329 // no constraints yet present), just returns `None`.
330 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
332 NoExpectation => NoExpectation,
333 ExpectCastableToType(t) => {
334 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
336 ExpectHasType(t) => {
337 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
339 ExpectRvalueLikeUnsized(t) => {
340 ExpectRvalueLikeUnsized(fcx.resolve_type_vars_if_possible(&t))
345 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
346 match self.resolve(fcx) {
347 NoExpectation => None,
348 ExpectCastableToType(ty) |
350 ExpectRvalueLikeUnsized(ty) => Some(ty),
354 /// It sometimes happens that we want to turn an expectation into
355 /// a **hard constraint** (i.e., something that must be satisfied
356 /// for the program to type-check). `only_has_type` will return
357 /// such a constraint, if it exists.
358 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
359 match self.resolve(fcx) {
360 ExpectHasType(ty) => Some(ty),
361 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
365 /// Like `only_has_type`, but instead of returning `None` if no
366 /// hard constraint exists, creates a fresh type variable.
367 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
368 self.only_has_type(fcx)
369 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
373 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
380 fn maybe_mut_place(m: hir::Mutability) -> Self {
382 hir::MutMutable => Needs::MutPlace,
383 hir::MutImmutable => Needs::None,
388 #[derive(Copy, Clone)]
389 pub struct UnsafetyState {
391 pub unsafety: hir::Unsafety,
392 pub unsafe_push_count: u32,
397 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
398 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
401 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
402 match self.unsafety {
403 // If this unsafe, then if the outer function was already marked as
404 // unsafe we shouldn't attribute the unsafe'ness to the block. This
405 // way the block can be warned about instead of ignoring this
406 // extraneous block (functions are never warned about).
407 hir::Unsafety::Unsafe if self.from_fn => *self,
410 let (unsafety, def, count) = match blk.rules {
411 hir::PushUnsafeBlock(..) =>
412 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
413 hir::PopUnsafeBlock(..) =>
414 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
415 hir::UnsafeBlock(..) =>
416 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
418 (unsafety, self.def, self.unsafe_push_count),
422 unsafe_push_count: count,
429 #[derive(Debug, Copy, Clone)]
435 /// Tracks whether executing a node may exit normally (versus
436 /// return/break/panic, which "diverge", leaving dead code in their
437 /// wake). Tracked semi-automatically (through type variables marked
438 /// as diverging), with some manual adjustments for control-flow
439 /// primitives (approximating a CFG).
440 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
442 /// Potentially unknown, some cases converge,
443 /// others require a CFG to determine them.
446 /// Definitely known to diverge and therefore
447 /// not reach the next sibling or its parent.
450 /// Same as `Always` but with a reachability
451 /// warning already emitted.
455 // Convenience impls for combinig `Diverges`.
457 impl ops::BitAnd for Diverges {
459 fn bitand(self, other: Self) -> Self {
460 cmp::min(self, other)
464 impl ops::BitOr for Diverges {
466 fn bitor(self, other: Self) -> Self {
467 cmp::max(self, other)
471 impl ops::BitAndAssign for Diverges {
472 fn bitand_assign(&mut self, other: Self) {
473 *self = *self & other;
477 impl ops::BitOrAssign for Diverges {
478 fn bitor_assign(&mut self, other: Self) {
479 *self = *self | other;
484 fn always(self) -> bool {
485 self >= Diverges::Always
489 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
492 // this is `null` for loops where break with a value is illegal,
493 // such as `while`, `for`, and `while let`
494 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
497 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
498 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
499 by_id: HirIdMap<usize>,
502 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
503 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
504 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
505 bug!("could not find enclosing breakable with id {}", target_id);
511 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
514 /// The parameter environment used for proving trait obligations
515 /// in this function. This can change when we descend into
516 /// closures (as they bring new things into scope), hence it is
517 /// not part of `Inherited` (as of the time of this writing,
518 /// closures do not yet change the environment, but they will
520 param_env: ty::ParamEnv<'tcx>,
522 // Number of errors that had been reported when we started
523 // checking this function. On exit, if we find that *more* errors
524 // have been reported, we will skip regionck and other work that
525 // expects the types within the function to be consistent.
526 err_count_on_creation: usize,
528 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
529 ret_coercion_span: RefCell<Option<Span>>,
531 yield_ty: Option<Ty<'tcx>>,
533 ps: RefCell<UnsafetyState>,
535 /// Whether the last checked node generates a divergence (e.g.,
536 /// `return` will set this to `Always`). In general, when entering
537 /// an expression or other node in the tree, the initial value
538 /// indicates whether prior parts of the containing expression may
539 /// have diverged. It is then typically set to `Maybe` (and the
540 /// old value remembered) for processing the subparts of the
541 /// current expression. As each subpart is processed, they may set
542 /// the flag to `Always`, etc. Finally, at the end, we take the
543 /// result and "union" it with the original value, so that when we
544 /// return the flag indicates if any subpart of the parent
545 /// expression (up to and including this part) has diverged. So,
546 /// if you read it after evaluating a subexpression `X`, the value
547 /// you get indicates whether any subexpression that was
548 /// evaluating up to and including `X` diverged.
550 /// We currently use this flag only for diagnostic purposes:
552 /// - To warn about unreachable code: if, after processing a
553 /// sub-expression but before we have applied the effects of the
554 /// current node, we see that the flag is set to `Always`, we
555 /// can issue a warning. This corresponds to something like
556 /// `foo(return)`; we warn on the `foo()` expression. (We then
557 /// update the flag to `WarnedAlways` to suppress duplicate
558 /// reports.) Similarly, if we traverse to a fresh statement (or
559 /// tail expression) from a `Always` setting, we will issue a
560 /// warning. This corresponds to something like `{return;
561 /// foo();}` or `{return; 22}`, where we would warn on the
564 /// An expression represents dead code if, after checking it,
565 /// the diverges flag is set to something other than `Maybe`.
566 diverges: Cell<Diverges>,
568 /// Whether any child nodes have any type errors.
569 has_errors: Cell<bool>,
571 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
573 inh: &'a Inherited<'a, 'gcx, 'tcx>,
576 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
577 type Target = Inherited<'a, 'gcx, 'tcx>;
578 fn deref(&self) -> &Self::Target {
583 /// Helper type of a temporary returned by `Inherited::build(...)`.
584 /// Necessary because we can't write the following bound:
585 /// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
586 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
587 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
591 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
592 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
593 -> InheritedBuilder<'a, 'gcx, 'tcx> {
594 let hir_id_root = if def_id.is_local() {
595 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
596 DefId::local(hir_id.owner)
602 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
608 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
609 fn enter<F, R>(&'tcx mut self, f: F) -> R
610 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
612 let def_id = self.def_id;
613 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
617 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
618 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
620 let item_id = tcx.hir().as_local_hir_id(def_id);
621 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
622 let implicit_region_bound = body_id.map(|body_id| {
623 let body = tcx.hir().body(body_id);
624 tcx.mk_region(ty::ReScope(region::Scope {
625 id: body.value.hir_id.local_id,
626 data: region::ScopeData::CallSite
631 tables: MaybeInProgressTables {
632 maybe_tables: infcx.in_progress_tables,
635 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
636 locals: RefCell::new(Default::default()),
637 deferred_sized_obligations: RefCell::new(Vec::new()),
638 deferred_call_resolutions: RefCell::new(Default::default()),
639 deferred_cast_checks: RefCell::new(Vec::new()),
640 deferred_generator_interiors: RefCell::new(Vec::new()),
641 opaque_types: RefCell::new(Default::default()),
642 implicit_region_bound,
647 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
648 debug!("register_predicate({:?})", obligation);
649 if obligation.has_escaping_bound_vars() {
650 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
655 .register_predicate_obligation(self, obligation);
658 fn register_predicates<I>(&self, obligations: I)
659 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
661 for obligation in obligations {
662 self.register_predicate(obligation);
666 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
667 self.register_predicates(infer_ok.obligations);
671 fn normalize_associated_types_in<T>(&self,
674 param_env: ty::ParamEnv<'tcx>,
676 where T : TypeFoldable<'tcx>
678 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
679 self.register_infer_ok_obligations(ok)
683 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
685 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
686 fn visit_item(&mut self, i: &'tcx hir::Item) {
687 check_item_type(self.tcx, i);
689 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
690 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
693 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
694 tcx.sess.track_errors(|| {
695 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
696 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
700 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
701 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
704 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) {
705 debug_assert!(crate_num == LOCAL_CRATE);
706 tcx.par_body_owners(|body_owner_def_id| {
707 tcx.ensure().typeck_tables_of(body_owner_def_id);
711 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
712 wfcheck::check_item_well_formed(tcx, def_id);
715 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
716 wfcheck::check_trait_item(tcx, def_id);
719 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
720 wfcheck::check_impl_item(tcx, def_id);
723 pub fn provide(providers: &mut Providers<'_>) {
724 method::provide(providers);
725 *providers = Providers {
731 check_item_well_formed,
732 check_trait_item_well_formed,
733 check_impl_item_well_formed,
734 check_mod_item_types,
739 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
741 -> Option<ty::Destructor> {
742 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
745 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
746 /// with information about it's body-id and fn-decl (if any). Otherwise,
749 /// If this function returns "some", then `typeck_tables(def_id)` will
750 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
751 /// may not succeed. In some cases where this function returns `None`
752 /// (notably closures), `typeck_tables(def_id)` would wind up
753 /// redirecting to the owning function.
754 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
756 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
758 match tcx.hir().get_by_hir_id(id) {
759 Node::Item(item) => {
761 hir::ItemKind::Const(_, body) |
762 hir::ItemKind::Static(_, _, body) =>
764 hir::ItemKind::Fn(ref decl, .., body) =>
765 Some((body, Some(decl))),
770 Node::TraitItem(item) => {
772 hir::TraitItemKind::Const(_, Some(body)) =>
774 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
775 Some((body, Some(&sig.decl))),
780 Node::ImplItem(item) => {
782 hir::ImplItemKind::Const(_, body) =>
784 hir::ImplItemKind::Method(ref sig, body) =>
785 Some((body, Some(&sig.decl))),
790 Node::AnonConst(constant) => Some((constant.body, None)),
795 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
798 // Closures' tables come from their outermost function,
799 // as they are part of the same "inference environment".
800 let outer_def_id = tcx.closure_base_def_id(def_id);
801 if outer_def_id != def_id {
802 return tcx.has_typeck_tables(outer_def_id);
805 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
806 primary_body_of(tcx, id).is_some()
809 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
812 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
815 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
817 -> &'tcx ty::TypeckTables<'tcx> {
818 // Closures' tables come from their outermost function,
819 // as they are part of the same "inference environment".
820 let outer_def_id = tcx.closure_base_def_id(def_id);
821 if outer_def_id != def_id {
822 return tcx.typeck_tables_of(outer_def_id);
825 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
826 let span = tcx.hir().span_by_hir_id(id);
828 // Figure out what primary body this item has.
829 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
830 span_bug!(span, "can't type-check body of {:?}", def_id);
832 let body = tcx.hir().body(body_id);
834 let tables = Inherited::build(tcx, def_id).enter(|inh| {
835 let param_env = tcx.param_env(def_id);
836 let fcx = if let Some(decl) = fn_decl {
837 let fn_sig = tcx.fn_sig(def_id);
839 check_abi(tcx, span, fn_sig.abi());
841 // Compute the fty from point of view of inside the fn.
843 tcx.liberate_late_bound_regions(def_id, &fn_sig);
845 inh.normalize_associated_types_in(body.value.span,
850 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
853 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
854 let expected_type = tcx.type_of(def_id);
855 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
856 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
858 let revealed_ty = if tcx.features().impl_trait_in_bindings {
859 fcx.instantiate_opaque_types_from_value(
867 // Gather locals in statics (because of block expressions).
868 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
870 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
872 fcx.write_ty(id, revealed_ty);
877 // All type checking constraints were added, try to fallback unsolved variables.
878 fcx.select_obligations_where_possible(false);
879 let mut fallback_has_occurred = false;
880 for ty in &fcx.unsolved_variables() {
881 fallback_has_occurred |= fcx.fallback_if_possible(ty);
883 fcx.select_obligations_where_possible(fallback_has_occurred);
885 // Even though coercion casts provide type hints, we check casts after fallback for
886 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
889 // Closure and generator analysis may run after fallback
890 // because they don't constrain other type variables.
891 fcx.closure_analyze(body);
892 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
893 fcx.resolve_generator_interiors(def_id);
895 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
896 let ty = fcx.normalize_ty(span, ty);
897 fcx.require_type_is_sized(ty, span, code);
899 fcx.select_all_obligations_or_error();
901 if fn_decl.is_some() {
902 fcx.regionck_fn(id, body);
904 fcx.regionck_expr(body);
907 fcx.resolve_type_vars_in_body(body)
910 // Consistency check our TypeckTables instance can hold all ItemLocalIds
911 // it will need to hold.
912 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
917 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
918 if !tcx.sess.target.target.is_abi_supported(abi) {
919 struct_span_err!(tcx.sess, span, E0570,
920 "The ABI `{}` is not supported for the current target", abi).emit()
924 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
925 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
926 parent_id: hir::HirId,
929 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
930 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
933 // infer the variable's type
934 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
935 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
942 // take type that the user specified
943 self.fcx.locals.borrow_mut().insert(nid, typ);
950 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
951 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
952 NestedVisitorMap::None
955 // Add explicitly-declared locals.
956 fn visit_local(&mut self, local: &'gcx hir::Local) {
957 let local_ty = match local.ty {
959 let o_ty = self.fcx.to_ty(&ty);
961 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
962 self.fcx.instantiate_opaque_types_from_value(
970 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
971 &UserType::Ty(revealed_ty)
973 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
974 ty.hir_id, o_ty, revealed_ty, c_ty);
975 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
977 Some(LocalTy { decl_ty: o_ty, revealed_ty })
981 self.assign(local.span, local.hir_id, local_ty);
983 debug!("Local variable {:?} is assigned type {}",
985 self.fcx.ty_to_string(
986 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
987 intravisit::walk_local(self, local);
990 // Add pattern bindings.
991 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
992 if let PatKind::Binding(_, _, ident, _) = p.node {
993 let var_ty = self.assign(p.span, p.hir_id, None);
995 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
996 if !self.fcx.tcx.features().unsized_locals {
997 self.fcx.require_type_is_sized(var_ty, p.span,
998 traits::VariableType(node_id));
1001 debug!("Pattern binding {} is assigned to {} with type {:?}",
1003 self.fcx.ty_to_string(
1004 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1007 intravisit::walk_pat(self, p);
1010 // Don't descend into the bodies of nested closures
1011 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1012 _: hir::BodyId, _: Span, _: hir::HirId) { }
1014 fn visit_argument_source(&mut self, s: &'gcx hir::ArgSource) {
1016 // Don't visit the pattern in `ArgSource::AsyncFn`, it contains a pattern which has
1017 // a `NodeId` w/out a type, as it is only used for getting the name of the original
1018 // pattern for diagnostics where only an `hir::Arg` is present.
1019 hir::ArgSource::AsyncFn(..) => {},
1020 _ => intravisit::walk_argument_source(self, s),
1025 /// When `check_fn` is invoked on a generator (i.e., a body that
1026 /// includes yield), it returns back some information about the yield
1028 struct GeneratorTypes<'tcx> {
1029 /// Type of value that is yielded.
1032 /// Types that are captured (see `GeneratorInterior` for more).
1035 /// Indicates if the generator is movable or static (immovable).
1036 movability: hir::GeneratorMovability,
1039 /// Helper used for fns and closures. Does the grungy work of checking a function
1040 /// body and returns the function context used for that purpose, since in the case of a fn item
1041 /// there is still a bit more to do.
1044 /// * inherited: other fields inherited from the enclosing fn (if any)
1045 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1046 param_env: ty::ParamEnv<'tcx>,
1047 fn_sig: ty::FnSig<'tcx>,
1048 decl: &'gcx hir::FnDecl,
1050 body: &'gcx hir::Body,
1051 can_be_generator: Option<hir::GeneratorMovability>)
1052 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1054 let mut fn_sig = fn_sig.clone();
1056 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1058 // Create the function context. This is either derived from scratch or,
1059 // in the case of closures, based on the outer context.
1060 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1061 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1063 let declared_ret_ty = fn_sig.output();
1064 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1065 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1066 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1067 fn_sig = fcx.tcx.mk_fn_sig(
1068 fn_sig.inputs().iter().cloned(),
1075 let span = body.value.span;
1077 if body.is_generator && can_be_generator.is_some() {
1078 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
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::MiscVariable(span));
1113 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1114 Some(GeneratorTypes {
1115 yield_ty: fcx.yield_ty.unwrap(),
1117 movability: can_be_generator.unwrap(),
1123 // Finalize the return check by taking the LUB of the return types
1124 // we saw and assigning it to the expected return type. This isn't
1125 // really expected to fail, since the coercions would have failed
1126 // earlier when trying to find a LUB.
1128 // However, the behavior around `!` is sort of complex. In the
1129 // event that the `actual_return_ty` comes back as `!`, that
1130 // indicates that the fn either does not return or "returns" only
1131 // values of type `!`. In this case, if there is an expected
1132 // return type that is *not* `!`, that should be ok. But if the
1133 // return type is being inferred, we want to "fallback" to `!`:
1135 // let x = move || panic!();
1137 // To allow for that, I am creating a type variable with diverging
1138 // fallback. This was deemed ever so slightly better than unifying
1139 // the return value with `!` because it allows for the caller to
1140 // make more assumptions about the return type (e.g., they could do
1142 // let y: Option<u32> = Some(x());
1144 // which would then cause this return type to become `u32`, not
1146 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1147 let mut actual_return_ty = coercion.complete(&fcx);
1148 if actual_return_ty.is_never() {
1149 actual_return_ty = fcx.next_diverging_ty_var(
1150 TypeVariableOrigin::DivergingFn(span));
1152 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1154 // Check that the main return type implements the termination trait.
1155 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1156 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1157 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1158 if main_id == fn_id {
1159 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1160 let trait_ref = ty::TraitRef::new(term_id, substs);
1161 let return_ty_span = decl.output.span();
1162 let cause = traits::ObligationCause::new(
1163 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1165 inherited.register_predicate(
1166 traits::Obligation::new(
1167 cause, param_env, trait_ref.to_predicate()));
1172 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1173 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1174 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1175 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1176 // at this point we don't care if there are duplicate handlers or if the handler has
1177 // the wrong signature as this value we'll be used when writing metadata and that
1178 // only happens if compilation succeeded
1179 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1181 if declared_ret_ty.sty != ty::Never {
1182 fcx.tcx.sess.span_err(
1184 "return type should be `!`",
1188 let inputs = fn_sig.inputs();
1189 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1190 if inputs.len() == 1 {
1191 let arg_is_panic_info = match inputs[0].sty {
1192 ty::Ref(region, ty, mutbl) => match ty.sty {
1193 ty::Adt(ref adt, _) => {
1194 adt.did == panic_info_did &&
1195 mutbl == hir::Mutability::MutImmutable &&
1196 *region != RegionKind::ReStatic
1203 if !arg_is_panic_info {
1204 fcx.tcx.sess.span_err(
1205 decl.inputs[0].span,
1206 "argument should be `&PanicInfo`",
1210 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1211 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1212 if !generics.params.is_empty() {
1213 fcx.tcx.sess.span_err(
1215 "should have no type parameters",
1221 let span = fcx.tcx.sess.source_map().def_span(span);
1222 fcx.tcx.sess.span_err(span, "function should have one argument");
1225 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1230 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1231 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1232 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1233 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1234 if declared_ret_ty.sty != ty::Never {
1235 fcx.tcx.sess.span_err(
1237 "return type should be `!`",
1241 let inputs = fn_sig.inputs();
1242 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1243 if inputs.len() == 1 {
1244 let arg_is_alloc_layout = match inputs[0].sty {
1245 ty::Adt(ref adt, _) => {
1246 adt.did == alloc_layout_did
1251 if !arg_is_alloc_layout {
1252 fcx.tcx.sess.span_err(
1253 decl.inputs[0].span,
1254 "argument should be `Layout`",
1258 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1259 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1260 if !generics.params.is_empty() {
1261 fcx.tcx.sess.span_err(
1263 "`#[alloc_error_handler]` function should have no type \
1270 let span = fcx.tcx.sess.source_map().def_span(span);
1271 fcx.tcx.sess.span_err(span, "function should have one argument");
1274 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1282 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1285 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1286 let def = tcx.adt_def(def_id);
1287 def.destructor(tcx); // force the destructor to be evaluated
1288 check_representable(tcx, span, def_id);
1290 if def.repr.simd() {
1291 check_simd(tcx, span, def_id);
1294 check_transparent(tcx, span, def_id);
1295 check_packed(tcx, span, def_id);
1298 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1301 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1302 let def = tcx.adt_def(def_id);
1303 def.destructor(tcx); // force the destructor to be evaluated
1304 check_representable(tcx, span, def_id);
1306 check_packed(tcx, span, def_id);
1309 fn check_opaque<'a, 'tcx>(
1310 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1312 substs: SubstsRef<'tcx>,
1315 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1316 let mut err = struct_span_err!(
1317 tcx.sess, span, E0720,
1318 "opaque type expands to a recursive type",
1320 err.span_label(span, "expands to self-referential type");
1321 if let ty::Opaque(..) = partially_expanded_type.sty {
1322 err.note("type resolves to itself");
1324 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1330 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1332 "check_item_type(it.hir_id={}, it.name={})",
1334 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1336 let _indenter = indenter();
1338 // Consts can play a role in type-checking, so they are included here.
1339 hir::ItemKind::Static(..) => {
1340 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1341 tcx.typeck_tables_of(def_id);
1342 maybe_check_static_with_link_section(tcx, def_id, it.span);
1344 hir::ItemKind::Const(..) => {
1345 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1347 hir::ItemKind::Enum(ref enum_definition, _) => {
1348 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1350 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1351 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1352 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1353 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1354 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1355 check_impl_items_against_trait(
1362 let trait_def_id = impl_trait_ref.def_id;
1363 check_on_unimplemented(tcx, trait_def_id, it);
1366 hir::ItemKind::Trait(..) => {
1367 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1368 check_on_unimplemented(tcx, def_id, it);
1370 hir::ItemKind::Struct(..) => {
1371 check_struct(tcx, it.hir_id, it.span);
1373 hir::ItemKind::Union(..) => {
1374 check_union(tcx, it.hir_id, it.span);
1376 hir::ItemKind::Existential(..) => {
1377 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1379 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1380 check_opaque(tcx, def_id, substs, it.span);
1382 hir::ItemKind::Ty(..) => {
1383 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1384 let pty_ty = tcx.type_of(def_id);
1385 let generics = tcx.generics_of(def_id);
1386 check_bounds_are_used(tcx, &generics, pty_ty);
1388 hir::ItemKind::ForeignMod(ref m) => {
1389 check_abi(tcx, it.span, m.abi);
1391 if m.abi == Abi::RustIntrinsic {
1392 for item in &m.items {
1393 intrinsic::check_intrinsic_type(tcx, item);
1395 } else if m.abi == Abi::PlatformIntrinsic {
1396 for item in &m.items {
1397 intrinsic::check_platform_intrinsic_type(tcx, item);
1400 for item in &m.items {
1401 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1402 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1403 let mut err = struct_span_err!(
1407 "foreign items may not have type parameters"
1409 err.span_label(item.span, "can't have type parameters");
1410 // FIXME: once we start storing spans for type arguments, turn this into a
1413 "use specialization instead of type parameters by replacing them \
1414 with concrete types like `u32`",
1419 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1420 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1425 _ => { /* nothing to do */ }
1429 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1430 // Only restricted on wasm32 target for now
1431 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1435 // If `#[link_section]` is missing, then nothing to verify
1436 let attrs = tcx.codegen_fn_attrs(id);
1437 if attrs.link_section.is_none() {
1441 // For the wasm32 target statics with #[link_section] are placed into custom
1442 // sections of the final output file, but this isn't link custom sections of
1443 // other executable formats. Namely we can only embed a list of bytes,
1444 // nothing with pointers to anything else or relocations. If any relocation
1445 // show up, reject them here.
1446 let instance = ty::Instance::mono(tcx, id);
1447 let cid = GlobalId {
1451 let param_env = ty::ParamEnv::reveal_all();
1452 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1453 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1456 bug!("Matching on non-ByRef static")
1458 if alloc.relocations.len() != 0 {
1459 let msg = "statics with a custom `#[link_section]` must be a \
1460 simple list of bytes on the wasm target with no \
1461 extra levels of indirection such as references";
1462 tcx.sess.span_err(span, msg);
1467 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1468 trait_def_id: DefId,
1470 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1471 // an error would be reported if this fails.
1472 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1475 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1476 impl_item: &hir::ImplItem,
1479 let mut err = struct_span_err!(
1480 tcx.sess, impl_item.span, E0520,
1481 "`{}` specializes an item from a parent `impl`, but \
1482 that item is not marked `default`",
1484 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1487 match tcx.span_of_impl(parent_impl) {
1489 err.span_label(span, "parent `impl` is here");
1490 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1494 err.note(&format!("parent implementation is in crate `{}`", cname));
1501 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1502 trait_def: &ty::TraitDef,
1503 trait_item: &ty::AssociatedItem,
1505 impl_item: &hir::ImplItem)
1507 let ancestors = trait_def.ancestors(tcx, impl_id);
1509 let kind = match impl_item.node {
1510 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1511 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1512 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1513 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1516 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1517 .map(|node_item| node_item.map(|parent| parent.defaultness));
1519 if let Some(parent) = parent {
1520 if tcx.impl_item_is_final(&parent) {
1521 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1527 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1530 impl_trait_ref: ty::TraitRef<'tcx>,
1531 impl_item_refs: &[hir::ImplItemRef]) {
1532 let impl_span = tcx.sess.source_map().def_span(impl_span);
1534 // If the trait reference itself is erroneous (so the compilation is going
1535 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1536 // isn't populated for such impls.
1537 if impl_trait_ref.references_error() { return; }
1539 // Locate trait definition and items
1540 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1541 let mut overridden_associated_type = None;
1543 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1545 // Check existing impl methods to see if they are both present in trait
1546 // and compatible with trait signature
1547 for impl_item in impl_items() {
1548 let ty_impl_item = tcx.associated_item(
1549 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1550 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1551 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1552 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1554 // Not compatible, but needed for the error message
1555 tcx.associated_items(impl_trait_ref.def_id)
1556 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1559 // Check that impl definition matches trait definition
1560 if let Some(ty_trait_item) = ty_trait_item {
1561 match impl_item.node {
1562 hir::ImplItemKind::Const(..) => {
1563 // Find associated const definition.
1564 if ty_trait_item.kind == ty::AssociatedKind::Const {
1565 compare_const_impl(tcx,
1571 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1572 "item `{}` is an associated const, \
1573 which doesn't match its trait `{}`",
1576 err.span_label(impl_item.span, "does not match trait");
1577 // We can only get the spans from local trait definition
1578 // Same for E0324 and E0325
1579 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1580 err.span_label(trait_span, "item in trait");
1585 hir::ImplItemKind::Method(..) => {
1586 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1587 if ty_trait_item.kind == ty::AssociatedKind::Method {
1588 compare_impl_method(tcx,
1595 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1596 "item `{}` is an associated method, \
1597 which doesn't match its trait `{}`",
1600 err.span_label(impl_item.span, "does not match trait");
1601 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1602 err.span_label(trait_span, "item in trait");
1607 hir::ImplItemKind::Existential(..) |
1608 hir::ImplItemKind::Type(_) => {
1609 if ty_trait_item.kind == ty::AssociatedKind::Type {
1610 if ty_trait_item.defaultness.has_value() {
1611 overridden_associated_type = Some(impl_item);
1614 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1615 "item `{}` is an associated type, \
1616 which doesn't match its trait `{}`",
1619 err.span_label(impl_item.span, "does not match trait");
1620 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1621 err.span_label(trait_span, "item in trait");
1628 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1632 // Check for missing items from trait
1633 let mut missing_items = Vec::new();
1634 let mut invalidated_items = Vec::new();
1635 let associated_type_overridden = overridden_associated_type.is_some();
1636 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1637 let is_implemented = trait_def.ancestors(tcx, impl_id)
1638 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1640 .map(|node_item| !node_item.node.is_from_trait())
1643 if !is_implemented && !tcx.impl_is_default(impl_id) {
1644 if !trait_item.defaultness.has_value() {
1645 missing_items.push(trait_item);
1646 } else if associated_type_overridden {
1647 invalidated_items.push(trait_item.ident);
1652 if !missing_items.is_empty() {
1653 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1654 "not all trait items implemented, missing: `{}`",
1655 missing_items.iter()
1656 .map(|trait_item| trait_item.ident.to_string())
1657 .collect::<Vec<_>>().join("`, `"));
1658 err.span_label(impl_span, format!("missing `{}` in implementation",
1659 missing_items.iter()
1660 .map(|trait_item| trait_item.ident.to_string())
1661 .collect::<Vec<_>>().join("`, `")));
1662 for trait_item in missing_items {
1663 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1664 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1666 err.note_trait_signature(trait_item.ident.to_string(),
1667 trait_item.signature(tcx));
1673 if !invalidated_items.is_empty() {
1674 let invalidator = overridden_associated_type.unwrap();
1675 span_err!(tcx.sess, invalidator.span, E0399,
1676 "the following trait items need to be reimplemented \
1677 as `{}` was overridden: `{}`",
1679 invalidated_items.iter()
1680 .map(|name| name.to_string())
1681 .collect::<Vec<_>>().join("`, `"))
1685 /// Checks whether a type can be represented in memory. In particular, it
1686 /// identifies types that contain themselves without indirection through a
1687 /// pointer, which would mean their size is unbounded.
1688 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1692 let rty = tcx.type_of(item_def_id);
1694 // Check that it is possible to represent this type. This call identifies
1695 // (1) types that contain themselves and (2) types that contain a different
1696 // recursive type. It is only necessary to throw an error on those that
1697 // contain themselves. For case 2, there must be an inner type that will be
1698 // caught by case 1.
1699 match rty.is_representable(tcx, sp) {
1700 Representability::SelfRecursive(spans) => {
1701 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1703 err.span_label(span, "recursive without indirection");
1708 Representability::Representable | Representability::ContainsRecursive => (),
1713 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1714 let t = tcx.type_of(def_id);
1715 if let ty::Adt(def, substs) = t.sty {
1716 if def.is_struct() {
1717 let fields = &def.non_enum_variant().fields;
1718 if fields.is_empty() {
1719 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1722 let e = fields[0].ty(tcx, substs);
1723 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1724 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1725 .span_label(sp, "SIMD elements must have the same type")
1730 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1731 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1733 span_err!(tcx.sess, sp, E0077,
1734 "SIMD vector element type should be machine type");
1742 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1743 let repr = tcx.adt_def(def_id).repr;
1745 for attr in tcx.get_attrs(def_id).iter() {
1746 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1747 if let attr::ReprPacked(pack) = r {
1748 if pack != repr.pack {
1749 struct_span_err!(tcx.sess, sp, E0634,
1750 "type has conflicting packed representation hints").emit();
1756 struct_span_err!(tcx.sess, sp, E0587,
1757 "type has conflicting packed and align representation hints").emit();
1759 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1760 struct_span_err!(tcx.sess, sp, E0588,
1761 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1766 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1768 stack: &mut Vec<DefId>) -> bool {
1769 let t = tcx.type_of(def_id);
1770 if stack.contains(&def_id) {
1771 debug!("check_packed_inner: {:?} is recursive", t);
1774 if let ty::Adt(def, substs) = t.sty {
1775 if def.is_struct() || def.is_union() {
1776 if tcx.adt_def(def.did).repr.align > 0 {
1779 // push struct def_id before checking fields
1781 for field in &def.non_enum_variant().fields {
1782 let f = field.ty(tcx, substs);
1783 if let ty::Adt(def, _) = f.sty {
1784 if check_packed_inner(tcx, def.did, stack) {
1789 // only need to pop if not early out
1796 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1797 let adt = tcx.adt_def(def_id);
1798 if !adt.repr.transparent() {
1802 // For each field, figure out if it's known to be a ZST and align(1)
1803 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1804 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1805 let param_env = tcx.param_env(field.did);
1806 let layout = tcx.layout_of(param_env.and(ty));
1807 // We are currently checking the type this field came from, so it must be local
1808 let span = tcx.hir().span_if_local(field.did).unwrap();
1809 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1810 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1814 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1815 let non_zst_count = non_zst_fields.clone().count();
1816 if non_zst_count != 1 {
1817 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1818 struct_span_err!(tcx.sess, sp, E0690,
1819 "transparent struct needs exactly one non-zero-sized field, but has {}",
1821 .span_note(field_spans, "non-zero-sized field")
1824 for (span, zst, align1) in field_infos {
1826 span_err!(tcx.sess, span, E0691,
1827 "zero-sized field in transparent struct has alignment larger than 1");
1832 #[allow(trivial_numeric_casts)]
1833 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1835 vs: &'tcx [hir::Variant],
1837 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1838 let def = tcx.adt_def(def_id);
1839 def.destructor(tcx); // force the destructor to be evaluated
1842 let attributes = tcx.get_attrs(def_id);
1843 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1845 tcx.sess, attr.span, E0084,
1846 "unsupported representation for zero-variant enum")
1847 .span_label(sp, "zero-variant enum")
1852 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1853 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1854 if !tcx.features().repr128 {
1855 emit_feature_err(&tcx.sess.parse_sess,
1858 GateIssue::Language,
1859 "repr with 128-bit type is unstable");
1864 if let Some(ref e) = v.node.disr_expr {
1865 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1869 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1870 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1871 // Check for duplicate discriminant values
1872 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1873 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1874 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1875 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1876 let i_span = match variant_i.node.disr_expr {
1877 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1878 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1880 let span = match v.node.disr_expr {
1881 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1884 struct_span_err!(tcx.sess, span, E0081,
1885 "discriminant value `{}` already exists", disr_vals[i])
1886 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1887 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1890 disr_vals.push(discr);
1893 check_representable(tcx, sp, def_id);
1896 fn report_unexpected_variant_res<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1900 span_err!(tcx.sess, span, E0533,
1901 "expected unit struct/variant or constant, found {} `{}`",
1903 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1906 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1907 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1909 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1910 -> Lrc<ty::GenericPredicates<'tcx>>
1913 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1914 let item_id = tcx.hir().ty_param_owner(hir_id);
1915 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1916 let generics = tcx.generics_of(item_def_id);
1917 let index = generics.param_def_id_to_index[&def_id];
1918 Lrc::new(ty::GenericPredicates {
1920 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1922 ty::Predicate::Trait(ref data)
1923 if data.skip_binder().self_ty().is_param(index) => {
1924 // HACK(eddyb) should get the original `Span`.
1925 let span = tcx.def_span(def_id);
1926 Some((predicate, span))
1934 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1935 -> Option<ty::Region<'tcx>> {
1937 Some(def) => infer::EarlyBoundRegion(span, def.name),
1938 None => infer::MiscVariable(span)
1940 Some(self.next_region_var(v))
1943 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1944 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1947 fn ty_infer_for_def(&self,
1948 ty_param_def: &ty::GenericParamDef,
1949 span: Span) -> Ty<'tcx> {
1950 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1956 fn projected_ty_from_poly_trait_ref(&self,
1959 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1962 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1964 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1968 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1971 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1972 if ty.has_escaping_bound_vars() {
1973 ty // FIXME: normalization and escaping regions
1975 self.normalize_associated_types_in(span, &ty)
1979 fn set_tainted_by_errors(&self) {
1980 self.infcx.set_tainted_by_errors()
1983 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1984 self.write_ty(hir_id, ty)
1988 /// Controls whether the arguments are tupled. This is used for the call
1991 /// Tupling means that all call-side arguments are packed into a tuple and
1992 /// passed as a single parameter. For example, if tupling is enabled, this
1995 /// fn f(x: (isize, isize))
1997 /// Can be called as:
2004 #[derive(Clone, Eq, PartialEq)]
2005 enum TupleArgumentsFlag {
2010 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2011 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2012 param_env: ty::ParamEnv<'tcx>,
2013 body_id: hir::HirId)
2014 -> FnCtxt<'a, 'gcx, 'tcx> {
2018 err_count_on_creation: inh.tcx.sess.err_count(),
2020 ret_coercion_span: RefCell::new(None),
2022 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2023 hir::CRATE_HIR_ID)),
2024 diverges: Cell::new(Diverges::Maybe),
2025 has_errors: Cell::new(false),
2026 enclosing_breakables: RefCell::new(EnclosingBreakables {
2028 by_id: Default::default(),
2034 pub fn sess(&self) -> &Session {
2038 pub fn err_count_since_creation(&self) -> usize {
2039 self.tcx.sess.err_count() - self.err_count_on_creation
2042 /// Produces warning on the given node, if the current point in the
2043 /// function is unreachable, and there hasn't been another warning.
2044 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2045 if self.diverges.get() == Diverges::Always &&
2046 // If span arose from a desugaring of `if` then it is the condition itself,
2047 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2048 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2049 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2050 self.diverges.set(Diverges::WarnedAlways);
2052 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2054 let msg = format!("unreachable {}", kind);
2055 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2061 code: ObligationCauseCode<'tcx>)
2062 -> ObligationCause<'tcx> {
2063 ObligationCause::new(span, self.body_id, code)
2066 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2067 self.cause(span, ObligationCauseCode::MiscObligation)
2070 /// Resolves type variables in `ty` if possible. Unlike the infcx
2071 /// version (resolve_type_vars_if_possible), this version will
2072 /// also select obligations if it seems useful, in an effort
2073 /// to get more type information.
2074 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2075 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2077 // No Infer()? Nothing needs doing.
2078 if !ty.has_infer_types() {
2079 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2083 // If `ty` is a type variable, see whether we already know what it is.
2084 ty = self.resolve_type_vars_if_possible(&ty);
2085 if !ty.has_infer_types() {
2086 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2090 // If not, try resolving pending obligations as much as
2091 // possible. This can help substantially when there are
2092 // indirect dependencies that don't seem worth tracking
2094 self.select_obligations_where_possible(false);
2095 ty = self.resolve_type_vars_if_possible(&ty);
2097 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2101 fn record_deferred_call_resolution(&self,
2102 closure_def_id: DefId,
2103 r: DeferredCallResolution<'gcx, 'tcx>) {
2104 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2105 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2108 fn remove_deferred_call_resolutions(&self,
2109 closure_def_id: DefId)
2110 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2112 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2113 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2116 pub fn tag(&self) -> String {
2117 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2118 format!("{:?}", self_ptr)
2121 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2122 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2123 span_bug!(span, "no type for local variable {}",
2124 self.tcx.hir().hir_to_string(nid))
2129 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2130 debug!("write_ty({:?}, {:?}) in fcx {}",
2131 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2132 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2134 if ty.references_error() {
2135 self.has_errors.set(true);
2136 self.set_tainted_by_errors();
2140 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2141 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2144 pub fn write_method_call(&self,
2146 method: MethodCallee<'tcx>) {
2147 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2150 .type_dependent_defs_mut()
2151 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2153 self.write_substs(hir_id, method.substs);
2155 // When the method is confirmed, the `method.substs` includes
2156 // parameters from not just the method, but also the impl of
2157 // the method -- in particular, the `Self` type will be fully
2158 // resolved. However, those are not something that the "user
2159 // specified" -- i.e., those types come from the inferred type
2160 // of the receiver, not something the user wrote. So when we
2161 // create the user-substs, we want to replace those earlier
2162 // types with just the types that the user actually wrote --
2163 // that is, those that appear on the *method itself*.
2165 // As an example, if the user wrote something like
2166 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2167 // type of `foo` (possibly adjusted), but we don't want to
2168 // include that. We want just the `[_, u32]` part.
2169 if !method.substs.is_noop() {
2170 let method_generics = self.tcx.generics_of(method.def_id);
2171 if !method_generics.params.is_empty() {
2172 let user_type_annotation = self.infcx.probe(|_| {
2173 let user_substs = UserSubsts {
2174 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2175 let i = param.index as usize;
2176 if i < method_generics.parent_count {
2177 self.infcx.var_for_def(DUMMY_SP, param)
2182 user_self_ty: None, // not relevant here
2185 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2191 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2192 self.write_user_type_annotation(hir_id, user_type_annotation);
2197 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2198 if !substs.is_noop() {
2199 debug!("write_substs({:?}, {:?}) in fcx {}",
2204 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2208 /// Given the substs that we just converted from the HIR, try to
2209 /// canonicalize them and store them as user-given substitutions
2210 /// (i.e., substitutions that must be respected by the NLL check).
2212 /// This should be invoked **before any unifications have
2213 /// occurred**, so that annotations like `Vec<_>` are preserved
2215 pub fn write_user_type_annotation_from_substs(
2219 substs: SubstsRef<'tcx>,
2220 user_self_ty: Option<UserSelfTy<'tcx>>,
2223 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2224 user_self_ty={:?} in fcx {}",
2225 hir_id, def_id, substs, user_self_ty, self.tag(),
2228 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2229 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2230 &UserType::TypeOf(def_id, UserSubsts {
2235 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2236 self.write_user_type_annotation(hir_id, canonicalized);
2240 pub fn write_user_type_annotation(
2243 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2246 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2247 hir_id, canonical_user_type_annotation, self.tag(),
2250 if !canonical_user_type_annotation.is_identity() {
2251 self.tables.borrow_mut().user_provided_types_mut().insert(
2252 hir_id, canonical_user_type_annotation
2255 debug!("write_user_type_annotation: skipping identity substs");
2259 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2260 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2266 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2267 Entry::Vacant(entry) => { entry.insert(adj); },
2268 Entry::Occupied(mut entry) => {
2269 debug!(" - composing on top of {:?}", entry.get());
2270 match (&entry.get()[..], &adj[..]) {
2271 // Applying any adjustment on top of a NeverToAny
2272 // is a valid NeverToAny adjustment, because it can't
2274 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2276 Adjustment { kind: Adjust::Deref(_), .. },
2277 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2279 Adjustment { kind: Adjust::Deref(_), .. },
2280 .. // Any following adjustments are allowed.
2282 // A reborrow has no effect before a dereference.
2284 // FIXME: currently we never try to compose autoderefs
2285 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2287 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2288 expr, entry.get(), adj)
2290 *entry.get_mut() = adj;
2295 /// Basically whenever we are converting from a type scheme into
2296 /// the fn body space, we always want to normalize associated
2297 /// types as well. This function combines the two.
2298 fn instantiate_type_scheme<T>(&self,
2300 substs: SubstsRef<'tcx>,
2303 where T : TypeFoldable<'tcx>
2305 let value = value.subst(self.tcx, substs);
2306 let result = self.normalize_associated_types_in(span, &value);
2307 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2314 /// As `instantiate_type_scheme`, but for the bounds found in a
2315 /// generic type scheme.
2316 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2317 -> ty::InstantiatedPredicates<'tcx> {
2318 let bounds = self.tcx.predicates_of(def_id);
2319 let result = bounds.instantiate(self.tcx, substs);
2320 let result = self.normalize_associated_types_in(span, &result);
2321 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2328 /// Replaces the opaque types from the given value with type variables,
2329 /// and records the `OpaqueTypeMap` for later use during writeback. See
2330 /// `InferCtxt::instantiate_opaque_types` for more details.
2331 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2333 parent_id: hir::HirId,
2336 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2337 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2341 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2342 self.instantiate_opaque_types(
2350 let mut opaque_types = self.opaque_types.borrow_mut();
2351 for (ty, decl) in opaque_type_map {
2352 let old_value = opaque_types.insert(ty, decl);
2353 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2359 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2360 where T : TypeFoldable<'tcx>
2362 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2365 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2367 where T : TypeFoldable<'tcx>
2369 self.inh.partially_normalize_associated_types_in(span,
2375 pub fn require_type_meets(&self,
2378 code: traits::ObligationCauseCode<'tcx>,
2381 self.register_bound(
2384 traits::ObligationCause::new(span, self.body_id, code));
2387 pub fn require_type_is_sized(&self,
2390 code: traits::ObligationCauseCode<'tcx>)
2392 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2393 self.require_type_meets(ty, span, code, lang_item);
2396 pub fn require_type_is_sized_deferred(&self,
2399 code: traits::ObligationCauseCode<'tcx>)
2401 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2404 pub fn register_bound(&self,
2407 cause: traits::ObligationCause<'tcx>)
2409 self.fulfillment_cx.borrow_mut()
2410 .register_bound(self, self.param_env, ty, def_id, cause);
2413 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2414 let t = AstConv::ast_ty_to_ty(self, ast_t);
2415 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2419 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2420 let ty = self.to_ty(ast_ty);
2421 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2423 if Self::can_contain_user_lifetime_bounds(ty) {
2424 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2425 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2426 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2432 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2433 AstConv::ast_const_to_const(self, ast_c, ty)
2436 // If the type given by the user has free regions, save it for later, since
2437 // NLL would like to enforce those. Also pass in types that involve
2438 // projections, since those can resolve to `'static` bounds (modulo #54940,
2439 // which hopefully will be fixed by the time you see this comment, dear
2440 // reader, although I have my doubts). Also pass in types with inference
2441 // types, because they may be repeated. Other sorts of things are already
2442 // sufficiently enforced with erased regions. =)
2443 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2445 T: TypeFoldable<'tcx>
2447 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2450 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2451 match self.tables.borrow().node_types().get(id) {
2453 None if self.is_tainted_by_errors() => self.tcx.types.err,
2455 let node_id = self.tcx.hir().hir_to_node_id(id);
2456 bug!("no type for node {}: {} in fcx {}",
2457 node_id, self.tcx.hir().node_to_string(node_id),
2463 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2464 /// outlive the region `r`.
2465 pub fn register_wf_obligation(&self,
2468 code: traits::ObligationCauseCode<'tcx>)
2470 // WF obligations never themselves fail, so no real need to give a detailed cause:
2471 let cause = traits::ObligationCause::new(span, self.body_id, code);
2472 self.register_predicate(traits::Obligation::new(cause,
2474 ty::Predicate::WellFormed(ty)));
2477 /// Registers obligations that all types appearing in `substs` are well-formed.
2478 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2479 for ty in substs.types() {
2480 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2484 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2485 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2486 /// trait/region obligations.
2488 /// For example, if there is a function:
2491 /// fn foo<'a,T:'a>(...)
2494 /// and a reference:
2500 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2501 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2502 pub fn add_obligations_for_parameters(&self,
2503 cause: traits::ObligationCause<'tcx>,
2504 predicates: &ty::InstantiatedPredicates<'tcx>)
2506 assert!(!predicates.has_escaping_bound_vars());
2508 debug!("add_obligations_for_parameters(predicates={:?})",
2511 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2512 self.register_predicate(obligation);
2516 // FIXME(arielb1): use this instead of field.ty everywhere
2517 // Only for fields! Returns <none> for methods>
2518 // Indifferent to privacy flags
2519 pub fn field_ty(&self,
2521 field: &'tcx ty::FieldDef,
2522 substs: SubstsRef<'tcx>)
2525 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2528 fn check_casts(&self) {
2529 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2530 for cast in deferred_cast_checks.drain(..) {
2535 fn resolve_generator_interiors(&self, def_id: DefId) {
2536 let mut generators = self.deferred_generator_interiors.borrow_mut();
2537 for (body_id, interior) in generators.drain(..) {
2538 self.select_obligations_where_possible(false);
2539 generator_interior::resolve_interior(self, def_id, body_id, interior);
2543 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2544 // Non-numerics get replaced with ! or () (depending on whether
2545 // feature(never_type) is enabled, unconstrained ints with i32,
2546 // unconstrained floats with f64.
2547 // Fallback becomes very dubious if we have encountered type-checking errors.
2548 // In that case, fallback to Error.
2549 // The return value indicates whether fallback has occurred.
2550 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2551 use rustc::ty::error::UnconstrainedNumeric::Neither;
2552 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2554 assert!(ty.is_ty_infer());
2555 let fallback = match self.type_is_unconstrained_numeric(ty) {
2556 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2557 UnconstrainedInt => self.tcx.types.i32,
2558 UnconstrainedFloat => self.tcx.types.f64,
2559 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2560 Neither => return false,
2562 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2563 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2567 fn select_all_obligations_or_error(&self) {
2568 debug!("select_all_obligations_or_error");
2569 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2570 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2574 /// Select as many obligations as we can at present.
2575 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2576 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2577 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2581 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2582 /// returns a type of `&T`, but the actual type we assign to the
2583 /// *expression* is `T`. So this function just peels off the return
2584 /// type by one layer to yield `T`.
2585 fn make_overloaded_place_return_type(&self,
2586 method: MethodCallee<'tcx>)
2587 -> ty::TypeAndMut<'tcx>
2589 // extract method return type, which will be &T;
2590 let ret_ty = method.sig.output();
2592 // method returns &T, but the type as visible to user is T, so deref
2593 ret_ty.builtin_deref(true).unwrap()
2596 fn lookup_indexing(&self,
2598 base_expr: &'gcx hir::Expr,
2602 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2604 // FIXME(#18741) -- this is almost but not quite the same as the
2605 // autoderef that normal method probing does. They could likely be
2608 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2609 let mut result = None;
2610 while result.is_none() && autoderef.next().is_some() {
2611 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2613 autoderef.finalize(self);
2617 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2618 /// (and otherwise adjust) `base_expr`, looking for a type which either
2619 /// supports builtin indexing or overloaded indexing.
2620 /// This loop implements one step in that search; the autoderef loop
2621 /// is implemented by `lookup_indexing`.
2622 fn try_index_step(&self,
2624 base_expr: &hir::Expr,
2625 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2628 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2630 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2631 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2638 for &unsize in &[false, true] {
2639 let mut self_ty = adjusted_ty;
2641 // We only unsize arrays here.
2642 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2643 self_ty = self.tcx.mk_slice(element_ty);
2649 // If some lookup succeeds, write callee into table and extract index/element
2650 // type from the method signature.
2651 // If some lookup succeeded, install method in table
2652 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2653 let method = self.try_overloaded_place_op(
2654 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2656 let result = method.map(|ok| {
2657 debug!("try_index_step: success, using overloaded indexing");
2658 let method = self.register_infer_ok_obligations(ok);
2660 let mut adjustments = autoderef.adjust_steps(self, needs);
2661 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2662 let mutbl = match r_mutbl {
2663 hir::MutImmutable => AutoBorrowMutability::Immutable,
2664 hir::MutMutable => AutoBorrowMutability::Mutable {
2665 // Indexing can be desugared to a method call,
2666 // so maybe we could use two-phase here.
2667 // See the documentation of AllowTwoPhase for why that's
2668 // not the case today.
2669 allow_two_phase_borrow: AllowTwoPhase::No,
2672 adjustments.push(Adjustment {
2673 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2674 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2681 adjustments.push(Adjustment {
2682 kind: Adjust::Pointer(PointerCast::Unsize),
2683 target: method.sig.inputs()[0]
2686 self.apply_adjustments(base_expr, adjustments);
2688 self.write_method_call(expr.hir_id, method);
2689 (input_ty, self.make_overloaded_place_return_type(method).ty)
2691 if result.is_some() {
2699 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2700 let (tr, name) = match (op, is_mut) {
2701 (PlaceOp::Deref, false) =>
2702 (self.tcx.lang_items().deref_trait(), "deref"),
2703 (PlaceOp::Deref, true) =>
2704 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2705 (PlaceOp::Index, false) =>
2706 (self.tcx.lang_items().index_trait(), "index"),
2707 (PlaceOp::Index, true) =>
2708 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2710 (tr, ast::Ident::from_str(name))
2713 fn try_overloaded_place_op(&self,
2716 arg_tys: &[Ty<'tcx>],
2719 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2721 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2727 // Try Mut first, if needed.
2728 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2729 let method = match (needs, mut_tr) {
2730 (Needs::MutPlace, Some(trait_did)) => {
2731 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2736 // Otherwise, fall back to the immutable version.
2737 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2738 let method = match (method, imm_tr) {
2739 (None, Some(trait_did)) => {
2740 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2742 (method, _) => method,
2748 fn check_method_argument_types(&self,
2751 method: Result<MethodCallee<'tcx>, ()>,
2752 args_no_rcvr: &'gcx [hir::Expr],
2753 tuple_arguments: TupleArgumentsFlag,
2754 expected: Expectation<'tcx>)
2756 let has_error = match method {
2758 method.substs.references_error() || method.sig.references_error()
2763 let err_inputs = self.err_args(args_no_rcvr.len());
2765 let err_inputs = match tuple_arguments {
2766 DontTupleArguments => err_inputs,
2767 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2770 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2771 false, tuple_arguments, None);
2772 return self.tcx.types.err;
2775 let method = method.unwrap();
2776 // HACK(eddyb) ignore self in the definition (see above).
2777 let expected_arg_tys = self.expected_inputs_for_expected_output(
2780 method.sig.output(),
2781 &method.sig.inputs()[1..]
2783 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2784 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2785 self.tcx.hir().span_if_local(method.def_id));
2789 fn self_type_matches_expected_vid(
2791 trait_ref: ty::PolyTraitRef<'tcx>,
2792 expected_vid: ty::TyVid,
2794 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2796 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2797 trait_ref, self_ty, expected_vid
2800 ty::Infer(ty::TyVar(found_vid)) => {
2801 // FIXME: consider using `sub_root_var` here so we
2802 // can see through subtyping.
2803 let found_vid = self.root_var(found_vid);
2804 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2805 expected_vid == found_vid
2811 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2812 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2813 + Captures<'gcx> + 'b
2815 // FIXME: consider using `sub_root_var` here so we
2816 // can see through subtyping.
2817 let ty_var_root = self.root_var(self_ty);
2818 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2819 self_ty, ty_var_root,
2820 self.fulfillment_cx.borrow().pending_obligations());
2824 .pending_obligations()
2826 .filter_map(move |obligation| match obligation.predicate {
2827 ty::Predicate::Projection(ref data) =>
2828 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2829 ty::Predicate::Trait(ref data) =>
2830 Some((data.to_poly_trait_ref(), obligation)),
2831 ty::Predicate::Subtype(..) => None,
2832 ty::Predicate::RegionOutlives(..) => None,
2833 ty::Predicate::TypeOutlives(..) => None,
2834 ty::Predicate::WellFormed(..) => None,
2835 ty::Predicate::ObjectSafe(..) => None,
2836 ty::Predicate::ConstEvaluatable(..) => None,
2837 // N.B., this predicate is created by breaking down a
2838 // `ClosureType: FnFoo()` predicate, where
2839 // `ClosureType` represents some `Closure`. It can't
2840 // possibly be referring to the current closure,
2841 // because we haven't produced the `Closure` for
2842 // this closure yet; this is exactly why the other
2843 // code is looking for a self type of a unresolved
2844 // inference variable.
2845 ty::Predicate::ClosureKind(..) => None,
2846 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2849 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2850 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2851 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2855 /// Generic function that factors out common logic from function calls,
2856 /// method calls and overloaded operators.
2857 fn check_argument_types(&self,
2860 fn_inputs: &[Ty<'tcx>],
2861 expected_arg_tys: &[Ty<'tcx>],
2862 args: &'gcx [hir::Expr],
2864 tuple_arguments: TupleArgumentsFlag,
2865 def_span: Option<Span>) {
2868 // Grab the argument types, supplying fresh type variables
2869 // if the wrong number of arguments were supplied
2870 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2876 // All the input types from the fn signature must outlive the call
2877 // so as to validate implied bounds.
2878 for &fn_input_ty in fn_inputs {
2879 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2882 let expected_arg_count = fn_inputs.len();
2884 let param_count_error = |expected_count: usize,
2889 let mut err = tcx.sess.struct_span_err_with_code(sp,
2890 &format!("this function takes {}{} but {} {} supplied",
2891 if c_variadic { "at least " } else { "" },
2892 potentially_plural_count(expected_count, "parameter"),
2893 potentially_plural_count(arg_count, "parameter"),
2894 if arg_count == 1 {"was"} else {"were"}),
2895 DiagnosticId::Error(error_code.to_owned()));
2897 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2898 err.span_label(def_s, "defined here");
2901 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2902 // remove closing `)` from the span
2903 let sugg_span = sugg_span.shrink_to_lo();
2904 err.span_suggestion(
2906 "expected the unit value `()`; create it with empty parentheses",
2908 Applicability::MachineApplicable);
2910 err.span_label(sp, format!("expected {}{}",
2911 if c_variadic { "at least " } else { "" },
2912 potentially_plural_count(expected_count, "parameter")));
2917 let mut expected_arg_tys = expected_arg_tys.to_vec();
2919 let formal_tys = if tuple_arguments == TupleArguments {
2920 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2921 match tuple_type.sty {
2922 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2923 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2924 expected_arg_tys = vec![];
2925 self.err_args(args.len())
2927 ty::Tuple(arg_types) => {
2928 expected_arg_tys = match expected_arg_tys.get(0) {
2929 Some(&ty) => match ty.sty {
2930 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
2935 arg_types.iter().map(|k| k.expect_ty()).collect()
2938 span_err!(tcx.sess, sp, E0059,
2939 "cannot use call notation; the first type parameter \
2940 for the function trait is neither a tuple nor unit");
2941 expected_arg_tys = vec![];
2942 self.err_args(args.len())
2945 } else if expected_arg_count == supplied_arg_count {
2947 } else if c_variadic {
2948 if supplied_arg_count >= expected_arg_count {
2951 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2952 expected_arg_tys = vec![];
2953 self.err_args(supplied_arg_count)
2956 // is the missing argument of type `()`?
2957 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2958 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2959 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2960 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2964 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2966 expected_arg_tys = vec![];
2967 self.err_args(supplied_arg_count)
2970 debug!("check_argument_types: formal_tys={:?}",
2971 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2973 // If there is no expectation, expect formal_tys.
2974 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2980 // Check the arguments.
2981 // We do this in a pretty awful way: first we type-check any arguments
2982 // that are not closures, then we type-check the closures. This is so
2983 // that we have more information about the types of arguments when we
2984 // type-check the functions. This isn't really the right way to do this.
2985 for &check_closures in &[false, true] {
2986 debug!("check_closures={}", check_closures);
2988 // More awful hacks: before we check argument types, try to do
2989 // an "opportunistic" vtable resolution of any trait bounds on
2990 // the call. This helps coercions.
2992 self.select_obligations_where_possible(false);
2995 // For C-variadic functions, we don't have a declared type for all of
2996 // the arguments hence we only do our usual type checking with
2997 // the arguments who's types we do know.
2998 let t = if c_variadic {
3000 } else if tuple_arguments == TupleArguments {
3005 for (i, arg) in args.iter().take(t).enumerate() {
3006 // Warn only for the first loop (the "no closures" one).
3007 // Closure arguments themselves can't be diverging, but
3008 // a previous argument can, e.g., `foo(panic!(), || {})`.
3009 if !check_closures {
3010 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3013 let is_closure = match arg.node {
3014 ExprKind::Closure(..) => true,
3018 if is_closure != check_closures {
3022 debug!("checking the argument");
3023 let formal_ty = formal_tys[i];
3025 // The special-cased logic below has three functions:
3026 // 1. Provide as good of an expected type as possible.
3027 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3029 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3031 // 2. Coerce to the most detailed type that could be coerced
3032 // to, which is `expected_ty` if `rvalue_hint` returns an
3033 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3034 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3035 // We're processing function arguments so we definitely want to use
3036 // two-phase borrows.
3037 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3039 // 3. Relate the expected type and the formal one,
3040 // if the expected type was used for the coercion.
3041 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3045 // We also need to make sure we at least write the ty of the other
3046 // arguments which we skipped above.
3048 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3049 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3050 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3053 for arg in args.iter().skip(expected_arg_count) {
3054 let arg_ty = self.check_expr(&arg);
3056 // There are a few types which get autopromoted when passed via varargs
3057 // in C but we just error out instead and require explicit casts.
3058 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3060 ty::Float(ast::FloatTy::F32) => {
3061 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3063 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3064 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3066 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3067 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3070 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3071 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3072 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3080 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3081 vec![self.tcx.types.err; len]
3084 // AST fragment checking
3087 expected: Expectation<'tcx>)
3093 ast::LitKind::Str(..) => tcx.mk_static_str(),
3094 ast::LitKind::ByteStr(ref v) => {
3095 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3096 tcx.mk_array(tcx.types.u8, v.len() as u64))
3098 ast::LitKind::Byte(_) => tcx.types.u8,
3099 ast::LitKind::Char(_) => tcx.types.char,
3100 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3101 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3102 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3103 let opt_ty = expected.to_option(self).and_then(|ty| {
3105 ty::Int(_) | ty::Uint(_) => Some(ty),
3106 ty::Char => Some(tcx.types.u8),
3107 ty::RawPtr(..) => Some(tcx.types.usize),
3108 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3112 opt_ty.unwrap_or_else(|| self.next_int_var())
3114 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3115 ast::LitKind::FloatUnsuffixed(_) => {
3116 let opt_ty = expected.to_option(self).and_then(|ty| {
3118 ty::Float(_) => Some(ty),
3122 opt_ty.unwrap_or_else(|| self.next_float_var())
3124 ast::LitKind::Bool(_) => tcx.types.bool,
3125 ast::LitKind::Err(_) => tcx.types.err,
3129 fn check_expr_eq_type(&self,
3130 expr: &'gcx hir::Expr,
3131 expected: Ty<'tcx>) {
3132 let ty = self.check_expr_with_hint(expr, expected);
3133 self.demand_eqtype(expr.span, expected, ty);
3136 pub fn check_expr_has_type_or_error(&self,
3137 expr: &'gcx hir::Expr,
3138 expected: Ty<'tcx>) -> Ty<'tcx> {
3139 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3142 fn check_expr_meets_expectation_or_error(&self,
3143 expr: &'gcx hir::Expr,
3144 expected: Expectation<'tcx>) -> Ty<'tcx> {
3145 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3146 let mut ty = self.check_expr_with_expectation(expr, expected);
3148 // While we don't allow *arbitrary* coercions here, we *do* allow
3149 // coercions from ! to `expected`.
3151 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3152 "expression with never type wound up being adjusted");
3153 let adj_ty = self.next_diverging_ty_var(
3154 TypeVariableOrigin::AdjustmentType(expr.span));
3155 self.apply_adjustments(expr, vec![Adjustment {
3156 kind: Adjust::NeverToAny,
3162 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3163 let expr = match &expr.node {
3164 ExprKind::DropTemps(expr) => expr,
3167 // Error possibly reported in `check_assign` so avoid emitting error again.
3168 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3173 fn check_expr_coercable_to_type(&self,
3174 expr: &'gcx hir::Expr,
3175 expected: Ty<'tcx>) -> Ty<'tcx> {
3176 let ty = self.check_expr_with_hint(expr, expected);
3177 // checks don't need two phase
3178 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3181 fn check_expr_with_hint(&self,
3182 expr: &'gcx hir::Expr,
3183 expected: Ty<'tcx>) -> Ty<'tcx> {
3184 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3187 fn check_expr_with_expectation(&self,
3188 expr: &'gcx hir::Expr,
3189 expected: Expectation<'tcx>) -> Ty<'tcx> {
3190 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3193 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3194 self.check_expr_with_expectation(expr, NoExpectation)
3197 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3198 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3201 // Determine the `Self` type, using fresh variables for all variables
3202 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3203 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3205 pub fn impl_self_ty(&self,
3206 span: Span, // (potential) receiver for this impl
3208 -> TypeAndSubsts<'tcx> {
3209 let ity = self.tcx.type_of(did);
3210 debug!("impl_self_ty: ity={:?}", ity);
3212 let substs = self.fresh_substs_for_item(span, did);
3213 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3215 TypeAndSubsts { substs: substs, ty: substd_ty }
3218 /// Unifies the output type with the expected type early, for more coercions
3219 /// and forward type information on the input expressions.
3220 fn expected_inputs_for_expected_output(&self,
3222 expected_ret: Expectation<'tcx>,
3223 formal_ret: Ty<'tcx>,
3224 formal_args: &[Ty<'tcx>])
3226 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3227 let ret_ty = match expected_ret.only_has_type(self) {
3229 None => return Vec::new()
3231 let expect_args = self.fudge_inference_if_ok(|| {
3232 // Attempt to apply a subtyping relationship between the formal
3233 // return type (likely containing type variables if the function
3234 // is polymorphic) and the expected return type.
3235 // No argument expectations are produced if unification fails.
3236 let origin = self.misc(call_span);
3237 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3239 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3240 // to identity so the resulting type is not constrained.
3243 // Process any obligations locally as much as
3244 // we can. We don't care if some things turn
3245 // out unconstrained or ambiguous, as we're
3246 // just trying to get hints here.
3247 self.save_and_restore_in_snapshot_flag(|_| {
3248 let mut fulfill = TraitEngine::new(self.tcx);
3249 for obligation in ok.obligations {
3250 fulfill.register_predicate_obligation(self, obligation);
3252 fulfill.select_where_possible(self)
3253 }).map_err(|_| ())?;
3255 Err(_) => return Err(()),
3258 // Record all the argument types, with the substitutions
3259 // produced from the above subtyping unification.
3260 Ok(formal_args.iter().map(|ty| {
3261 self.resolve_type_vars_if_possible(ty)
3263 }).unwrap_or_default();
3264 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3265 formal_args, formal_ret,
3266 expect_args, expected_ret);
3270 // Checks a method call.
3271 fn check_method_call(&self,
3272 expr: &'gcx hir::Expr,
3273 segment: &hir::PathSegment,
3275 args: &'gcx [hir::Expr],
3276 expected: Expectation<'tcx>,
3277 needs: Needs) -> Ty<'tcx> {
3278 let rcvr = &args[0];
3279 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3280 // no need to check for bot/err -- callee does that
3281 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3283 let method = match self.lookup_method(rcvr_t,
3289 self.write_method_call(expr.hir_id, method);
3293 if segment.ident.name != keywords::Invalid.name() {
3294 self.report_method_error(span,
3297 SelfSource::MethodCall(rcvr),
3305 // Call the generic checker.
3306 self.check_method_argument_types(span,
3314 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3318 .unwrap_or_else(|| span_bug!(return_expr.span,
3319 "check_return_expr called outside fn body"));
3321 let ret_ty = ret_coercion.borrow().expected_ty();
3322 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3323 ret_coercion.borrow_mut()
3325 &self.cause(return_expr.span,
3326 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3331 // Check field access expressions
3332 fn check_field(&self,
3333 expr: &'gcx hir::Expr,
3335 base: &'gcx hir::Expr,
3336 field: ast::Ident) -> Ty<'tcx> {
3337 let expr_t = self.check_expr_with_needs(base, needs);
3338 let expr_t = self.structurally_resolved_type(base.span,
3340 let mut private_candidate = None;
3341 let mut autoderef = self.autoderef(expr.span, expr_t);
3342 while let Some((base_t, _)) = autoderef.next() {
3344 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3345 debug!("struct named {:?}", base_t);
3346 let (ident, def_scope) =
3347 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3348 let fields = &base_def.non_enum_variant().fields;
3349 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3350 let field = &fields[index];
3351 let field_ty = self.field_ty(expr.span, field, substs);
3352 // Save the index of all fields regardless of their visibility in case
3353 // of error recovery.
3354 self.write_field_index(expr.hir_id, index);
3355 if field.vis.is_accessible_from(def_scope, self.tcx) {
3356 let adjustments = autoderef.adjust_steps(self, needs);
3357 self.apply_adjustments(base, adjustments);
3358 autoderef.finalize(self);
3360 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3363 private_candidate = Some((base_def.did, field_ty));
3366 ty::Tuple(ref tys) => {
3367 let fstr = field.as_str();
3368 if let Ok(index) = fstr.parse::<usize>() {
3369 if fstr == index.to_string() {
3370 if let Some(field_ty) = tys.get(index) {
3371 let adjustments = autoderef.adjust_steps(self, needs);
3372 self.apply_adjustments(base, adjustments);
3373 autoderef.finalize(self);
3375 self.write_field_index(expr.hir_id, index);
3376 return field_ty.expect_ty();
3384 autoderef.unambiguous_final_ty(self);
3386 if let Some((did, field_ty)) = private_candidate {
3387 let struct_path = self.tcx().def_path_str(did);
3388 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3389 "field `{}` of struct `{}` is private",
3390 field, struct_path);
3391 // Also check if an accessible method exists, which is often what is meant.
3392 if self.method_exists(field, expr_t, expr.hir_id, false)
3393 && !self.expr_in_place(expr.hir_id)
3395 self.suggest_method_call(
3397 &format!("a method `{}` also exists, call it with parentheses", field),
3405 } else if field.name == keywords::Invalid.name() {
3406 self.tcx().types.err
3407 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3408 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3409 "attempted to take value of method `{}` on type `{}`",
3412 if !self.expr_in_place(expr.hir_id) {
3413 self.suggest_method_call(
3415 "use parentheses to call the method",
3421 err.help("methods are immutable and cannot be assigned to");
3425 self.tcx().types.err
3427 if !expr_t.is_primitive_ty() {
3428 let mut err = self.no_such_field_err(field.span, field, expr_t);
3431 ty::Adt(def, _) if !def.is_enum() => {
3432 if let Some(suggested_field_name) =
3433 Self::suggest_field_name(def.non_enum_variant(),
3434 &field.as_str(), vec![]) {
3435 err.span_suggestion(
3437 "a field with a similar name exists",
3438 suggested_field_name.to_string(),
3439 Applicability::MaybeIncorrect,
3442 err.span_label(field.span, "unknown field");
3443 let struct_variant_def = def.non_enum_variant();
3444 let field_names = self.available_field_names(struct_variant_def);
3445 if !field_names.is_empty() {
3446 err.note(&format!("available fields are: {}",
3447 self.name_series_display(field_names)));
3451 ty::Array(_, len) => {
3452 if let (Some(len), Ok(user_index)) = (
3453 len.assert_usize(self.tcx),
3454 field.as_str().parse::<u64>()
3456 let base = self.tcx.sess.source_map()
3457 .span_to_snippet(base.span)
3459 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3460 let help = "instead of using tuple indexing, use array indexing";
3461 let suggestion = format!("{}[{}]", base, field);
3462 let applicability = if len < user_index {
3463 Applicability::MachineApplicable
3465 Applicability::MaybeIncorrect
3467 err.span_suggestion(
3468 expr.span, help, suggestion, applicability
3473 let base = self.tcx.sess.source_map()
3474 .span_to_snippet(base.span)
3475 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3476 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3477 let suggestion = format!("(*{}).{}", base, field);
3478 err.span_suggestion(
3482 Applicability::MaybeIncorrect,
3489 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3490 "`{}` is a primitive type and therefore doesn't have fields",
3493 self.tcx().types.err
3497 // Return an hint about the closest match in field names
3498 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3500 skip: Vec<LocalInternedString>)
3502 let names = variant.fields.iter().filter_map(|field| {
3503 // ignore already set fields and private fields from non-local crates
3504 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3505 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3509 Some(&field.ident.name)
3513 find_best_match_for_name(names, field, None)
3516 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3517 variant.fields.iter().filter(|field| {
3518 let def_scope = self.tcx.adjust_ident(field.ident, variant.def_id, self.body_id).1;
3519 field.vis.is_accessible_from(def_scope, self.tcx)
3521 .map(|field| field.ident.name)
3525 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3526 // dynamic limit, to never omit just one field
3527 let limit = if names.len() == 6 { 6 } else { 5 };
3528 let mut display = names.iter().take(limit)
3529 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3530 if names.len() > limit {
3531 display = format!("{} ... and {} others", display, names.len() - limit);
3536 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3537 -> DiagnosticBuilder<'_> {
3538 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3539 "no field `{}` on type `{}`",
3543 fn report_unknown_field(
3546 variant: &'tcx ty::VariantDef,
3548 skip_fields: &[hir::Field],
3551 if variant.recovered {
3554 let mut err = self.type_error_struct_with_diag(
3556 |actual| match ty.sty {
3557 ty::Adt(adt, ..) if adt.is_enum() => {
3558 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3559 "{} `{}::{}` has no field named `{}`",
3560 kind_name, actual, variant.ident, field.ident)
3563 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3564 "{} `{}` has no field named `{}`",
3565 kind_name, actual, field.ident)
3569 // prevent all specified fields from being suggested
3570 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3571 if let Some(field_name) = Self::suggest_field_name(variant,
3572 &field.ident.as_str(),
3573 skip_fields.collect()) {
3574 err.span_suggestion(
3576 "a field with a similar name exists",
3577 field_name.to_string(),
3578 Applicability::MaybeIncorrect,
3582 ty::Adt(adt, ..) => {
3584 err.span_label(field.ident.span,
3585 format!("`{}::{}` does not have this field",
3586 ty, variant.ident));
3588 err.span_label(field.ident.span,
3589 format!("`{}` does not have this field", ty));
3591 let available_field_names = self.available_field_names(variant);
3592 if !available_field_names.is_empty() {
3593 err.note(&format!("available fields are: {}",
3594 self.name_series_display(available_field_names)));
3597 _ => bug!("non-ADT passed to report_unknown_field")
3603 fn check_expr_struct_fields(&self,
3605 expected: Expectation<'tcx>,
3606 expr_id: hir::HirId,
3608 variant: &'tcx ty::VariantDef,
3609 ast_fields: &'gcx [hir::Field],
3610 check_completeness: bool) -> bool {
3614 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3615 .get(0).cloned().unwrap_or(adt_ty);
3616 // re-link the regions that EIfEO can erase.
3617 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3619 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3620 &ty::Adt(adt, substs) => {
3621 (substs, adt.adt_kind(), adt.variant_descr())
3623 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3626 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3627 (field.ident.modern(), (i, field))
3628 ).collect::<FxHashMap<_, _>>();
3630 let mut seen_fields = FxHashMap::default();
3632 let mut error_happened = false;
3634 // Type-check each field.
3635 for field in ast_fields {
3636 let ident = tcx.adjust_ident(field.ident, variant.def_id, self.body_id).0;
3637 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3638 seen_fields.insert(ident, field.span);
3639 self.write_field_index(field.hir_id, i);
3641 // We don't look at stability attributes on
3642 // struct-like enums (yet...), but it's definitely not
3643 // a bug to have constructed one.
3644 if adt_kind != AdtKind::Enum {
3645 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3648 self.field_ty(field.span, v_field, substs)
3650 error_happened = true;
3651 if let Some(prev_span) = seen_fields.get(&ident) {
3652 let mut err = struct_span_err!(self.tcx.sess,
3655 "field `{}` specified more than once",
3658 err.span_label(field.ident.span, "used more than once");
3659 err.span_label(*prev_span, format!("first use of `{}`", ident));
3663 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3669 // Make sure to give a type to the field even if there's
3670 // an error, so we can continue type-checking.
3671 self.check_expr_coercable_to_type(&field.expr, field_type);
3674 // Make sure the programmer specified correct number of fields.
3675 if kind_name == "union" {
3676 if ast_fields.len() != 1 {
3677 tcx.sess.span_err(span, "union expressions should have exactly one field");
3679 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3680 let len = remaining_fields.len();
3682 let mut displayable_field_names = remaining_fields
3684 .map(|ident| ident.as_str())
3685 .collect::<Vec<_>>();
3687 displayable_field_names.sort();
3689 let truncated_fields_error = if len <= 3 {
3692 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3695 let remaining_fields_names = displayable_field_names.iter().take(3)
3696 .map(|n| format!("`{}`", n))
3697 .collect::<Vec<_>>()
3700 struct_span_err!(tcx.sess, span, E0063,
3701 "missing field{} {}{} in initializer of `{}`",
3702 if remaining_fields.len() == 1 { "" } else { "s" },
3703 remaining_fields_names,
3704 truncated_fields_error,
3706 .span_label(span, format!("missing {}{}",
3707 remaining_fields_names,
3708 truncated_fields_error))
3714 fn check_struct_fields_on_error(&self,
3715 fields: &'gcx [hir::Field],
3716 base_expr: &'gcx Option<P<hir::Expr>>) {
3717 for field in fields {
3718 self.check_expr(&field.expr);
3720 if let Some(ref base) = *base_expr {
3721 self.check_expr(&base);
3725 pub fn check_struct_path(&self,
3728 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3729 let path_span = match *qpath {
3730 QPath::Resolved(_, ref path) => path.span,
3731 QPath::TypeRelative(ref qself, _) => qself.span
3733 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3734 let variant = match def {
3736 self.set_tainted_by_errors();
3739 Res::Def(DefKind::Variant, _) => {
3741 ty::Adt(adt, substs) => {
3742 Some((adt.variant_of_res(def), adt.did, substs))
3744 _ => bug!("unexpected type: {:?}", ty)
3747 Res::Def(DefKind::Struct, _)
3748 | Res::Def(DefKind::Union, _)
3749 | Res::Def(DefKind::TyAlias, _)
3750 | Res::Def(DefKind::AssociatedTy, _)
3751 | Res::SelfTy(..) => {
3753 ty::Adt(adt, substs) if !adt.is_enum() => {
3754 Some((adt.non_enum_variant(), adt.did, substs))
3759 _ => bug!("unexpected definition: {:?}", def)
3762 if let Some((variant, did, substs)) = variant {
3763 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3764 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3766 // Check bounds on type arguments used in the path.
3767 let bounds = self.instantiate_bounds(path_span, did, substs);
3768 let cause = traits::ObligationCause::new(path_span, self.body_id,
3769 traits::ItemObligation(did));
3770 self.add_obligations_for_parameters(cause, &bounds);
3774 struct_span_err!(self.tcx.sess, path_span, E0071,
3775 "expected struct, variant or union type, found {}",
3776 ty.sort_string(self.tcx))
3777 .span_label(path_span, "not a struct")
3783 fn check_expr_struct(&self,
3785 expected: Expectation<'tcx>,
3787 fields: &'gcx [hir::Field],
3788 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3790 // Find the relevant variant
3791 let (variant, adt_ty) =
3792 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3795 self.check_struct_fields_on_error(fields, base_expr);
3796 return self.tcx.types.err;
3799 let path_span = match *qpath {
3800 QPath::Resolved(_, ref path) => path.span,
3801 QPath::TypeRelative(ref qself, _) => qself.span
3804 // Prohibit struct expressions when non-exhaustive flag is set.
3805 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3806 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3807 span_err!(self.tcx.sess, expr.span, E0639,
3808 "cannot create non-exhaustive {} using struct expression",
3809 adt.variant_descr());
3812 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3813 variant, fields, base_expr.is_none());
3814 if let &Some(ref base_expr) = base_expr {
3815 // If check_expr_struct_fields hit an error, do not attempt to populate
3816 // the fields with the base_expr. This could cause us to hit errors later
3817 // when certain fields are assumed to exist that in fact do not.
3818 if !error_happened {
3819 self.check_expr_has_type_or_error(base_expr, adt_ty);
3821 ty::Adt(adt, substs) if adt.is_struct() => {
3822 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3823 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3828 .fru_field_types_mut()
3829 .insert(expr.hir_id, fru_field_types);
3832 span_err!(self.tcx.sess, base_expr.span, E0436,
3833 "functional record update syntax requires a struct");
3838 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3844 /// If an expression has any sub-expressions that result in a type error,
3845 /// inspecting that expression's type with `ty.references_error()` will return
3846 /// true. Likewise, if an expression is known to diverge, inspecting its
3847 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3848 /// strict, _|_ can appear in the type of an expression that does not,
3849 /// itself, diverge: for example, fn() -> _|_.)
3850 /// Note that inspecting a type's structure *directly* may expose the fact
3851 /// that there are actually multiple representations for `Error`, so avoid
3852 /// that when err needs to be handled differently.
3853 fn check_expr_with_expectation_and_needs(&self,
3854 expr: &'gcx hir::Expr,
3855 expected: Expectation<'tcx>,
3856 needs: Needs) -> Ty<'tcx> {
3857 debug!(">> type-checking: expr={:?} expected={:?}",
3860 // Warn for expressions after diverging siblings.
3861 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3863 // Hide the outer diverging and has_errors flags.
3864 let old_diverges = self.diverges.get();
3865 let old_has_errors = self.has_errors.get();
3866 self.diverges.set(Diverges::Maybe);
3867 self.has_errors.set(false);
3869 let ty = self.check_expr_kind(expr, expected, needs);
3871 // Warn for non-block expressions with diverging children.
3873 ExprKind::Block(..) |
3874 ExprKind::Loop(..) | ExprKind::While(..) |
3875 ExprKind::Match(..) => {}
3877 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3880 // Any expression that produces a value of type `!` must have diverged
3882 self.diverges.set(self.diverges.get() | Diverges::Always);
3885 // Record the type, which applies it effects.
3886 // We need to do this after the warning above, so that
3887 // we don't warn for the diverging expression itself.
3888 self.write_ty(expr.hir_id, ty);
3890 // Combine the diverging and has_error flags.
3891 self.diverges.set(self.diverges.get() | old_diverges);
3892 self.has_errors.set(self.has_errors.get() | old_has_errors);
3894 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3895 debug!("... {:?}, expected is {:?}", ty, expected);
3902 expr: &'gcx hir::Expr,
3903 expected: Expectation<'tcx>,
3907 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3914 let id = expr.hir_id;
3916 ExprKind::Box(ref subexpr) => {
3917 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3919 ty::Adt(def, _) if def.is_box()
3920 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3924 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3925 tcx.mk_box(referent_ty)
3928 ExprKind::Lit(ref lit) => {
3929 self.check_lit(&lit, expected)
3931 ExprKind::Binary(op, ref lhs, ref rhs) => {
3932 self.check_binop(expr, op, lhs, rhs)
3934 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3935 self.check_binop_assign(expr, op, lhs, rhs)
3937 ExprKind::Unary(unop, ref oprnd) => {
3938 let expected_inner = match unop {
3939 hir::UnNot | hir::UnNeg => {
3946 let needs = match unop {
3947 hir::UnDeref => needs,
3950 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3954 if !oprnd_t.references_error() {
3955 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3958 if let Some(mt) = oprnd_t.builtin_deref(true) {
3960 } else if let Some(ok) = self.try_overloaded_deref(
3961 expr.span, oprnd_t, needs) {
3962 let method = self.register_infer_ok_obligations(ok);
3963 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3964 let mutbl = match mutbl {
3965 hir::MutImmutable => AutoBorrowMutability::Immutable,
3966 hir::MutMutable => AutoBorrowMutability::Mutable {
3967 // (It shouldn't actually matter for unary ops whether
3968 // we enable two-phase borrows or not, since a unary
3969 // op has no additional operands.)
3970 allow_two_phase_borrow: AllowTwoPhase::No,
3973 self.apply_adjustments(oprnd, vec![Adjustment {
3974 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3975 target: method.sig.inputs()[0]
3978 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3979 self.write_method_call(expr.hir_id, method);
3981 let mut err = type_error_struct!(
3986 "type `{}` cannot be dereferenced",
3989 let sp = tcx.sess.source_map().start_point(expr.span);
3990 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
3993 tcx.sess.parse_sess.expr_parentheses_needed(
4000 oprnd_t = tcx.types.err;
4004 let result = self.check_user_unop(expr, oprnd_t, unop);
4005 // If it's builtin, we can reuse the type, this helps inference.
4006 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4011 let result = self.check_user_unop(expr, oprnd_t, unop);
4012 // If it's builtin, we can reuse the type, this helps inference.
4013 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4021 ExprKind::AddrOf(mutbl, ref oprnd) => {
4022 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4024 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4025 if oprnd.is_place_expr() {
4026 // Places may legitimately have unsized types.
4027 // For example, dereferences of a fat pointer and
4028 // the last field of a struct can be unsized.
4031 Expectation::rvalue_hint(self, ty)
4037 let needs = Needs::maybe_mut_place(mutbl);
4038 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4040 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4041 if tm.ty.references_error() {
4044 // Note: at this point, we cannot say what the best lifetime
4045 // is to use for resulting pointer. We want to use the
4046 // shortest lifetime possible so as to avoid spurious borrowck
4047 // errors. Moreover, the longest lifetime will depend on the
4048 // precise details of the value whose address is being taken
4049 // (and how long it is valid), which we don't know yet until type
4050 // inference is complete.
4052 // Therefore, here we simply generate a region variable. The
4053 // region inferencer will then select the ultimate value.
4054 // Finally, borrowck is charged with guaranteeing that the
4055 // value whose address was taken can actually be made to live
4056 // as long as it needs to live.
4057 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4058 tcx.mk_ref(region, tm)
4061 ExprKind::Path(ref qpath) => {
4062 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4064 let ty = match res {
4066 self.set_tainted_by_errors();
4069 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4070 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4073 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4076 if let ty::FnDef(..) = ty.sty {
4077 let fn_sig = ty.fn_sig(tcx);
4078 if !tcx.features().unsized_locals {
4079 // We want to remove some Sized bounds from std functions,
4080 // but don't want to expose the removal to stable Rust.
4081 // i.e., we don't want to allow
4087 // to work in stable even if the Sized bound on `drop` is relaxed.
4088 for i in 0..fn_sig.inputs().skip_binder().len() {
4089 // We just want to check sizedness, so instead of introducing
4090 // placeholder lifetimes with probing, we just replace higher lifetimes
4092 let input = self.replace_bound_vars_with_fresh_vars(
4094 infer::LateBoundRegionConversionTime::FnCall,
4095 &fn_sig.input(i)).0;
4096 self.require_type_is_sized_deferred(input, expr.span,
4097 traits::SizedArgumentType);
4100 // Here we want to prevent struct constructors from returning unsized types.
4101 // There were two cases this happened: fn pointer coercion in stable
4102 // and usual function call in presense of unsized_locals.
4103 // Also, as we just want to check sizedness, instead of introducing
4104 // placeholder lifetimes with probing, we just replace higher lifetimes
4106 let output = self.replace_bound_vars_with_fresh_vars(
4108 infer::LateBoundRegionConversionTime::FnCall,
4109 &fn_sig.output()).0;
4110 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4113 // We always require that the type provided as the value for
4114 // a type parameter outlives the moment of instantiation.
4115 let substs = self.tables.borrow().node_substs(expr.hir_id);
4116 self.add_wf_bounds(substs, expr);
4120 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4121 for expr in outputs.iter().chain(inputs.iter()) {
4122 self.check_expr(expr);
4126 ExprKind::Break(destination, ref expr_opt) => {
4127 if let Ok(target_id) = destination.target_id {
4129 if let Some(ref e) = *expr_opt {
4130 // If this is a break with a value, we need to type-check
4131 // the expression. Get an expected type from the loop context.
4132 let opt_coerce_to = {
4133 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4134 enclosing_breakables.find_breakable(target_id)
4137 .map(|coerce| coerce.expected_ty())
4140 // If the loop context is not a `loop { }`, then break with
4141 // a value is illegal, and `opt_coerce_to` will be `None`.
4142 // Just set expectation to error in that case.
4143 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4145 // Recurse without `enclosing_breakables` borrowed.
4146 e_ty = self.check_expr_with_hint(e, coerce_to);
4147 cause = self.misc(e.span);
4149 // Otherwise, this is a break *without* a value. That's
4150 // always legal, and is equivalent to `break ()`.
4151 e_ty = tcx.mk_unit();
4152 cause = self.misc(expr.span);
4155 // Now that we have type-checked `expr_opt`, borrow
4156 // the `enclosing_loops` field and let's coerce the
4157 // type of `expr_opt` into what is expected.
4158 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4159 let ctxt = enclosing_breakables.find_breakable(target_id);
4160 if let Some(ref mut coerce) = ctxt.coerce {
4161 if let Some(ref e) = *expr_opt {
4162 coerce.coerce(self, &cause, e, e_ty);
4164 assert!(e_ty.is_unit());
4165 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4168 // If `ctxt.coerce` is `None`, we can just ignore
4169 // the type of the expresison. This is because
4170 // either this was a break *without* a value, in
4171 // which case it is always a legal type (`()`), or
4172 // else an error would have been flagged by the
4173 // `loops` pass for using break with an expression
4174 // where you are not supposed to.
4175 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4178 ctxt.may_break = true;
4180 // the type of a `break` is always `!`, since it diverges
4183 // Otherwise, we failed to find the enclosing loop;
4184 // this can only happen if the `break` was not
4185 // inside a loop at all, which is caught by the
4186 // loop-checking pass.
4187 if self.tcx.sess.err_count() == 0 {
4188 self.tcx.sess.delay_span_bug(expr.span,
4189 "break was outside loop, but no error was emitted");
4192 // We still need to assign a type to the inner expression to
4193 // prevent the ICE in #43162.
4194 if let Some(ref e) = *expr_opt {
4195 self.check_expr_with_hint(e, tcx.types.err);
4197 // ... except when we try to 'break rust;'.
4198 // ICE this expression in particular (see #43162).
4199 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4200 if path.segments.len() == 1 &&
4201 path.segments[0].ident.name == sym::rust {
4202 fatally_break_rust(self.tcx.sess);
4206 // There was an error; make type-check fail.
4211 ExprKind::Continue(destination) => {
4212 if destination.target_id.is_ok() {
4215 // There was an error; make type-check fail.
4219 ExprKind::Ret(ref expr_opt) => {
4220 if self.ret_coercion.is_none() {
4221 struct_span_err!(self.tcx.sess, expr.span, E0572,
4222 "return statement outside of function body").emit();
4223 } else if let Some(ref e) = *expr_opt {
4224 if self.ret_coercion_span.borrow().is_none() {
4225 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4227 self.check_return_expr(e);
4229 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4230 if self.ret_coercion_span.borrow().is_none() {
4231 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4233 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4234 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4235 coercion.coerce_forced_unit(
4240 fn_decl.output.span(),
4242 "expected `{}` because of this return type",
4250 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4255 ExprKind::Assign(ref lhs, ref rhs) => {
4256 self.check_assign(expr, expected, lhs, rhs)
4258 ExprKind::While(ref cond, ref body, _) => {
4259 let ctxt = BreakableCtxt {
4260 // cannot use break with a value from a while loop
4262 may_break: false, // Will get updated if/when we find a `break`.
4265 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4266 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4267 let cond_diverging = self.diverges.get();
4268 self.check_block_no_value(&body);
4270 // We may never reach the body so it diverging means nothing.
4271 self.diverges.set(cond_diverging);
4275 // No way to know whether it's diverging because
4276 // of a `break` or an outer `break` or `return`.
4277 self.diverges.set(Diverges::Maybe);
4282 ExprKind::Loop(ref body, _, source) => {
4283 let coerce = match source {
4284 // you can only use break with a value from a normal `loop { }`
4285 hir::LoopSource::Loop => {
4286 let coerce_to = expected.coercion_target_type(self, body.span);
4287 Some(CoerceMany::new(coerce_to))
4290 hir::LoopSource::WhileLet |
4291 hir::LoopSource::ForLoop => {
4296 let ctxt = BreakableCtxt {
4298 may_break: false, // Will get updated if/when we find a `break`.
4301 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4302 self.check_block_no_value(&body);
4306 // No way to know whether it's diverging because
4307 // of a `break` or an outer `break` or `return`.
4308 self.diverges.set(Diverges::Maybe);
4311 // If we permit break with a value, then result type is
4312 // the LUB of the breaks (possibly ! if none); else, it
4313 // is nil. This makes sense because infinite loops
4314 // (which would have type !) are only possible iff we
4315 // permit break with a value [1].
4316 if ctxt.coerce.is_none() && !ctxt.may_break {
4318 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4320 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4322 ExprKind::Match(ref discrim, ref arms, match_src) => {
4323 self.check_match(expr, &discrim, arms, expected, match_src)
4325 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4326 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4328 ExprKind::Block(ref body, _) => {
4329 self.check_block_with_expected(&body, expected)
4331 ExprKind::Call(ref callee, ref args) => {
4332 self.check_call(expr, &callee, args, expected)
4334 ExprKind::MethodCall(ref segment, span, ref args) => {
4335 self.check_method_call(expr, segment, span, args, expected, needs)
4337 ExprKind::Cast(ref e, ref t) => {
4338 // Find the type of `e`. Supply hints based on the type we are casting to,
4340 let t_cast = self.to_ty_saving_user_provided_ty(t);
4341 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4342 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4343 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4345 // Eagerly check for some obvious errors.
4346 if t_expr.references_error() || t_cast.references_error() {
4349 // Defer other checks until we're done type checking.
4350 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4351 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4353 deferred_cast_checks.push(cast_check);
4356 Err(ErrorReported) => {
4362 ExprKind::Type(ref e, ref t) => {
4363 let ty = self.to_ty_saving_user_provided_ty(&t);
4364 self.check_expr_eq_type(&e, ty);
4367 ExprKind::DropTemps(ref e) => {
4368 self.check_expr_with_expectation(e, expected)
4370 ExprKind::Array(ref args) => {
4371 let uty = expected.to_option(self).and_then(|uty| {
4373 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4378 let element_ty = if !args.is_empty() {
4379 let coerce_to = uty.unwrap_or_else(
4380 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4381 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4382 assert_eq!(self.diverges.get(), Diverges::Maybe);
4384 let e_ty = self.check_expr_with_hint(e, coerce_to);
4385 let cause = self.misc(e.span);
4386 coerce.coerce(self, &cause, e, e_ty);
4388 coerce.complete(self)
4390 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4392 tcx.mk_array(element_ty, args.len() as u64)
4394 ExprKind::Repeat(ref element, ref count) => {
4395 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4396 let param_env = ty::ParamEnv::empty();
4397 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4398 let instance = ty::Instance::resolve(
4404 let global_id = GlobalId {
4408 let count = tcx.const_eval(param_env.and(global_id));
4410 let uty = match expected {
4411 ExpectHasType(uty) => {
4413 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4420 let (element_ty, t) = match uty {
4422 self.check_expr_coercable_to_type(&element, uty);
4426 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4427 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4432 if let Ok(count) = count {
4433 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4435 // For [foo, ..n] where n > 1, `foo` must have
4437 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4438 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4442 if element_ty.references_error() {
4444 } else if let Ok(count) = count {
4445 tcx.mk_ty(ty::Array(t, tcx.mk_const(count)))
4450 ExprKind::Tup(ref elts) => {
4451 let flds = expected.only_has_type(self).and_then(|ty| {
4452 let ty = self.resolve_type_vars_with_obligations(ty);
4454 ty::Tuple(ref flds) => Some(&flds[..]),
4459 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4460 let t = match flds {
4461 Some(ref fs) if i < fs.len() => {
4462 let ety = fs[i].expect_ty();
4463 self.check_expr_coercable_to_type(&e, ety);
4467 self.check_expr_with_expectation(&e, NoExpectation)
4472 let tuple = tcx.mk_tup(elt_ts_iter);
4473 if tuple.references_error() {
4476 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4480 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4481 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4483 ExprKind::Field(ref base, field) => {
4484 self.check_field(expr, needs, &base, field)
4486 ExprKind::Index(ref base, ref idx) => {
4487 let base_t = self.check_expr_with_needs(&base, needs);
4488 let idx_t = self.check_expr(&idx);
4490 if base_t.references_error() {
4492 } else if idx_t.references_error() {
4495 let base_t = self.structurally_resolved_type(base.span, base_t);
4496 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4497 Some((index_ty, element_ty)) => {
4498 // two-phase not needed because index_ty is never mutable
4499 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4504 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4505 "cannot index into a value of type `{}`",
4507 // Try to give some advice about indexing tuples.
4508 if let ty::Tuple(..) = base_t.sty {
4509 let mut needs_note = true;
4510 // If the index is an integer, we can show the actual
4511 // fixed expression:
4512 if let ExprKind::Lit(ref lit) = idx.node {
4513 if let ast::LitKind::Int(i,
4514 ast::LitIntType::Unsuffixed) = lit.node {
4515 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4516 if let Ok(snip) = snip {
4517 err.span_suggestion(
4519 "to access tuple elements, use",
4520 format!("{}.{}", snip, i),
4521 Applicability::MachineApplicable,
4528 err.help("to access tuple elements, use tuple indexing \
4529 syntax (e.g., `tuple.0`)");
4538 ExprKind::Yield(ref value) => {
4539 match self.yield_ty {
4541 self.check_expr_coercable_to_type(&value, ty);
4544 struct_span_err!(self.tcx.sess, expr.span, E0627,
4545 "yield statement outside of generator literal").emit();
4550 hir::ExprKind::Err => {
4556 /// Type check assignment expression `expr` of form `lhs = rhs`.
4557 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4560 expr: &'gcx hir::Expr,
4561 expected: Expectation<'tcx>,
4562 lhs: &'gcx hir::Expr,
4563 rhs: &'gcx hir::Expr,
4565 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4566 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4568 let expected_ty = expected.coercion_target_type(self, expr.span);
4569 if expected_ty == self.tcx.types.bool {
4570 // The expected type is `bool` but this will result in `()` so we can reasonably
4571 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4572 // The likely cause of this is `if foo = bar { .. }`.
4573 let actual_ty = self.tcx.mk_unit();
4574 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4575 let msg = "try comparing for equality";
4576 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4577 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4578 if let (Ok(left), Ok(right)) = (left, right) {
4579 let help = format!("{} == {}", left, right);
4580 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4585 } else if !lhs.is_place_expr() {
4586 struct_span_err!(self.tcx.sess, expr.span, E0070,
4587 "invalid left-hand side expression")
4588 .span_label(expr.span, "left-hand of expression not valid")
4592 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4594 if lhs_ty.references_error() || rhs_ty.references_error() {
4601 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4602 // The newly resolved definition is written into `type_dependent_defs`.
4603 fn finish_resolving_struct_path(&self,
4610 QPath::Resolved(ref maybe_qself, ref path) => {
4611 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4612 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4615 QPath::TypeRelative(ref qself, ref segment) => {
4616 let ty = self.to_ty(qself);
4618 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4623 let result = AstConv::associated_path_to_ty(
4632 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4633 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4635 // Write back the new resolution.
4636 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4638 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4643 /// Resolves associated value path into a base type and associated constant or method
4644 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4645 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4649 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4651 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4652 let (ty, qself, item_segment) = match *qpath {
4653 QPath::Resolved(ref opt_qself, ref path) => {
4655 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4656 &path.segments[..]);
4658 QPath::TypeRelative(ref qself, ref segment) => {
4659 (self.to_ty(qself), qself, segment)
4662 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4663 // Return directly on cache hit. This is useful to avoid doubly reporting
4664 // errors with default match binding modes. See #44614.
4665 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4666 .unwrap_or(Res::Err);
4667 return (def, Some(ty), slice::from_ref(&**item_segment));
4669 let item_name = item_segment.ident;
4670 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4671 let result = match error {
4672 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4673 _ => Err(ErrorReported),
4675 if item_name.name != keywords::Invalid.name() {
4676 self.report_method_error(
4680 SelfSource::QPath(qself),
4688 // Write back the new resolution.
4689 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4691 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4693 slice::from_ref(&**item_segment),
4697 pub fn check_decl_initializer(&self,
4698 local: &'gcx hir::Local,
4699 init: &'gcx hir::Expr) -> Ty<'tcx>
4701 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4702 // for #42640 (default match binding modes).
4705 let ref_bindings = local.pat.contains_explicit_ref_binding();
4707 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4708 if let Some(m) = ref_bindings {
4709 // Somewhat subtle: if we have a `ref` binding in the pattern,
4710 // we want to avoid introducing coercions for the RHS. This is
4711 // both because it helps preserve sanity and, in the case of
4712 // ref mut, for soundness (issue #23116). In particular, in
4713 // the latter case, we need to be clear that the type of the
4714 // referent for the reference that results is *equal to* the
4715 // type of the place it is referencing, and not some
4716 // supertype thereof.
4717 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4718 self.demand_eqtype(init.span, local_ty, init_ty);
4721 self.check_expr_coercable_to_type(init, local_ty)
4725 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4726 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4727 self.write_ty(local.hir_id, t);
4729 if let Some(ref init) = local.init {
4730 let init_ty = self.check_decl_initializer(local, &init);
4731 if init_ty.references_error() {
4732 self.write_ty(local.hir_id, init_ty);
4736 self.check_pat_walk(
4739 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4742 let pat_ty = self.node_ty(local.pat.hir_id);
4743 if pat_ty.references_error() {
4744 self.write_ty(local.hir_id, pat_ty);
4748 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4749 // Don't do all the complex logic below for `DeclItem`.
4751 hir::StmtKind::Item(..) => return,
4752 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4755 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4757 // Hide the outer diverging and `has_errors` flags.
4758 let old_diverges = self.diverges.get();
4759 let old_has_errors = self.has_errors.get();
4760 self.diverges.set(Diverges::Maybe);
4761 self.has_errors.set(false);
4764 hir::StmtKind::Local(ref l) => {
4765 self.check_decl_local(&l);
4768 hir::StmtKind::Item(_) => {}
4769 hir::StmtKind::Expr(ref expr) => {
4770 // Check with expected type of `()`.
4771 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4773 hir::StmtKind::Semi(ref expr) => {
4774 self.check_expr(&expr);
4778 // Combine the diverging and `has_error` flags.
4779 self.diverges.set(self.diverges.get() | old_diverges);
4780 self.has_errors.set(self.has_errors.get() | old_has_errors);
4783 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4784 let unit = self.tcx.mk_unit();
4785 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4787 // if the block produces a `!` value, that can always be
4788 // (effectively) coerced to unit.
4790 self.demand_suptype(blk.span, unit, ty);
4794 fn check_block_with_expected(&self,
4795 blk: &'gcx hir::Block,
4796 expected: Expectation<'tcx>) -> Ty<'tcx> {
4798 let mut fcx_ps = self.ps.borrow_mut();
4799 let unsafety_state = fcx_ps.recurse(blk);
4800 replace(&mut *fcx_ps, unsafety_state)
4803 // In some cases, blocks have just one exit, but other blocks
4804 // can be targeted by multiple breaks. This can happen both
4805 // with labeled blocks as well as when we desugar
4806 // a `try { ... }` expression.
4810 // 'a: { if true { break 'a Err(()); } Ok(()) }
4812 // Here we would wind up with two coercions, one from
4813 // `Err(())` and the other from the tail expression
4814 // `Ok(())`. If the tail expression is omitted, that's a
4815 // "forced unit" -- unless the block diverges, in which
4816 // case we can ignore the tail expression (e.g., `'a: {
4817 // break 'a 22; }` would not force the type of the block
4819 let tail_expr = blk.expr.as_ref();
4820 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4821 let coerce = if blk.targeted_by_break {
4822 CoerceMany::new(coerce_to_ty)
4824 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4825 Some(e) => slice::from_ref(e),
4828 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4831 let prev_diverges = self.diverges.get();
4832 let ctxt = BreakableCtxt {
4833 coerce: Some(coerce),
4837 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4838 for s in &blk.stmts {
4842 // check the tail expression **without** holding the
4843 // `enclosing_breakables` lock below.
4844 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4846 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4847 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4848 let coerce = ctxt.coerce.as_mut().unwrap();
4849 if let Some(tail_expr_ty) = tail_expr_ty {
4850 let tail_expr = tail_expr.unwrap();
4851 let cause = self.cause(tail_expr.span,
4852 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4858 // Subtle: if there is no explicit tail expression,
4859 // that is typically equivalent to a tail expression
4860 // of `()` -- except if the block diverges. In that
4861 // case, there is no value supplied from the tail
4862 // expression (assuming there are no other breaks,
4863 // this implies that the type of the block will be
4866 // #41425 -- label the implicit `()` as being the
4867 // "found type" here, rather than the "expected type".
4868 if !self.diverges.get().always() {
4869 // #50009 -- Do not point at the entire fn block span, point at the return type
4870 // span, as it is the cause of the requirement, and
4871 // `consider_hint_about_removing_semicolon` will point at the last expression
4872 // if it were a relevant part of the error. This improves usability in editors
4873 // that highlight errors inline.
4874 let mut sp = blk.span;
4875 let mut fn_span = None;
4876 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4877 let ret_sp = decl.output.span();
4878 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4879 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4880 // output would otherwise be incorrect and even misleading. Make sure
4881 // the span we're aiming at correspond to a `fn` body.
4882 if block_sp == blk.span {
4884 fn_span = Some(ident.span);
4888 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4889 if let Some(expected_ty) = expected.only_has_type(self) {
4890 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4892 if let Some(fn_span) = fn_span {
4893 err.span_label(fn_span, "this function's body doesn't return");
4901 // If we can break from the block, then the block's exit is always reachable
4902 // (... as long as the entry is reachable) - regardless of the tail of the block.
4903 self.diverges.set(prev_diverges);
4906 let mut ty = ctxt.coerce.unwrap().complete(self);
4908 if self.has_errors.get() || ty.references_error() {
4909 ty = self.tcx.types.err
4912 self.write_ty(blk.hir_id, ty);
4914 *self.ps.borrow_mut() = prev;
4918 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4919 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4921 Node::Item(&hir::Item {
4922 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4924 Node::ImplItem(&hir::ImplItem {
4925 node: hir::ImplItemKind::Method(_, body_id), ..
4927 let body = self.tcx.hir().body(body_id);
4928 if let ExprKind::Block(block, _) = &body.value.node {
4929 return Some(block.span);
4937 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4938 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4939 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4940 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4943 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4944 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4946 Node::Item(&hir::Item {
4947 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4948 }) => decl.clone().and_then(|decl| {
4949 // This is less than ideal, it will not suggest a return type span on any
4950 // method called `main`, regardless of whether it is actually the entry point,
4951 // but it will still present it as the reason for the expected type.
4952 Some((decl, ident, ident.name != Symbol::intern("main")))
4954 Node::TraitItem(&hir::TraitItem {
4955 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4958 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
4959 Node::ImplItem(&hir::ImplItem {
4960 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4963 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
4968 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4969 /// suggestion can be made, `None` otherwise.
4970 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
4971 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4972 // `while` before reaching it, as block tail returns are not available in them.
4973 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4974 let parent = self.tcx.hir().get_by_hir_id(blk_id);
4975 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4979 /// On implicit return expressions with mismatched types, provides the following suggestions:
4981 /// - Points out the method's return type as the reason for the expected type.
4982 /// - Possible missing semicolon.
4983 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4984 pub fn suggest_mismatched_types_on_tail(
4986 err: &mut DiagnosticBuilder<'tcx>,
4987 expression: &'gcx hir::Expr,
4993 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4994 let mut pointing_at_return_type = false;
4995 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4996 pointing_at_return_type = self.suggest_missing_return_type(
4997 err, &fn_decl, expected, found, can_suggest);
4999 self.suggest_ref_or_into(err, expression, expected, found);
5000 pointing_at_return_type
5003 pub fn suggest_ref_or_into(
5005 err: &mut DiagnosticBuilder<'tcx>,
5010 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5011 err.span_suggestion(
5015 Applicability::MachineApplicable,
5017 } else if !self.check_for_cast(err, expr, found, expected) {
5018 let methods = self.get_conversion_methods(expr.span, expected, found);
5019 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5020 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5021 .filter_map(|(receiver, method)| {
5022 let method_call = format!(".{}()", method.ident);
5023 if receiver.ends_with(&method_call) {
5024 None // do not suggest code that is already there (#53348)
5026 let method_call_list = [".to_vec()", ".to_string()"];
5027 if receiver.ends_with(".clone()")
5028 && method_call_list.contains(&method_call.as_str()) {
5029 let max_len = receiver.rfind(".").unwrap();
5030 Some(format!("{}{}", &receiver[..max_len], method_call))
5033 Some(format!("{}{}", receiver, method_call))
5037 if suggestions.peek().is_some() {
5038 err.span_suggestions(
5040 "try using a conversion method",
5042 Applicability::MaybeIncorrect,
5049 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5053 /// bar_that_returns_u32()
5057 /// This routine checks if the return expression in a block would make sense on its own as a
5058 /// statement and the return type has been left as default or has been specified as `()`. If so,
5059 /// it suggests adding a semicolon.
5060 fn suggest_missing_semicolon(&self,
5061 err: &mut DiagnosticBuilder<'tcx>,
5062 expression: &'gcx hir::Expr,
5065 if expected.is_unit() {
5066 // `BlockTailExpression` only relevant if the tail expr would be
5067 // useful on its own.
5068 match expression.node {
5069 ExprKind::Call(..) |
5070 ExprKind::MethodCall(..) |
5071 ExprKind::While(..) |
5072 ExprKind::Loop(..) |
5073 ExprKind::Match(..) |
5074 ExprKind::Block(..) => {
5075 let sp = self.tcx.sess.source_map().next_point(cause_span);
5076 err.span_suggestion(
5078 "try adding a semicolon",
5080 Applicability::MachineApplicable);
5087 /// A possible error is to forget to add a return type that is needed:
5091 /// bar_that_returns_u32()
5095 /// This routine checks if the return type is left as default, the method is not part of an
5096 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5098 fn suggest_missing_return_type(
5100 err: &mut DiagnosticBuilder<'tcx>,
5101 fn_decl: &hir::FnDecl,
5106 // Only suggest changing the return type for methods that
5107 // haven't set a return type at all (and aren't `fn main()` or an impl).
5108 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5109 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5110 err.span_suggestion(
5112 "try adding a return type",
5113 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5114 Applicability::MachineApplicable);
5117 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5118 err.span_label(span, "possibly return type missing here?");
5121 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5122 // `fn main()` must return `()`, do not suggest changing return type
5123 err.span_label(span, "expected `()` because of default return type");
5126 // expectation was caused by something else, not the default return
5127 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5128 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5129 // Only point to return type if the expected type is the return type, as if they
5130 // are not, the expectation must have been caused by something else.
5131 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5133 let ty = AstConv::ast_ty_to_ty(self, ty);
5134 debug!("suggest_missing_return_type: return type {:?}", ty);
5135 debug!("suggest_missing_return_type: expected type {:?}", ty);
5136 if ty.sty == expected.sty {
5137 err.span_label(sp, format!("expected `{}` because of return type",
5146 /// A common error is to add an extra semicolon:
5149 /// fn foo() -> usize {
5154 /// This routine checks if the final statement in a block is an
5155 /// expression with an explicit semicolon whose type is compatible
5156 /// with `expected_ty`. If so, it suggests removing the semicolon.
5157 fn consider_hint_about_removing_semicolon(
5159 blk: &'gcx hir::Block,
5160 expected_ty: Ty<'tcx>,
5161 err: &mut DiagnosticBuilder<'_>,
5163 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5164 err.span_suggestion(
5166 "consider removing this semicolon",
5168 Applicability::MachineApplicable,
5173 fn could_remove_semicolon(
5175 blk: &'gcx hir::Block,
5176 expected_ty: Ty<'tcx>,
5178 // Be helpful when the user wrote `{... expr;}` and
5179 // taking the `;` off is enough to fix the error.
5180 let last_stmt = blk.stmts.last()?;
5181 let last_expr = match last_stmt.node {
5182 hir::StmtKind::Semi(ref e) => e,
5185 let last_expr_ty = self.node_ty(last_expr.hir_id);
5186 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5189 let original_span = original_sp(last_stmt.span, blk.span);
5190 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5193 // Rewrite `SelfCtor` to `Ctor`
5194 pub fn rewrite_self_ctor(
5198 ) -> Result<(DefKind, DefId, Ty<'tcx>), ErrorReported> {
5200 if let Res::SelfCtor(impl_def_id) = res {
5201 let ty = self.impl_self_ty(span, impl_def_id).ty;
5202 let adt_def = ty.ty_adt_def();
5205 Some(adt_def) if adt_def.has_ctor() => {
5206 let variant = adt_def.non_enum_variant();
5207 let ctor_def_id = variant.ctor_def_id.unwrap();
5209 DefKind::Ctor(CtorOf::Struct, variant.ctor_kind),
5211 tcx.type_of(ctor_def_id),
5215 let mut err = tcx.sess.struct_span_err(span,
5216 "the `Self` constructor can only be used with tuple or unit structs");
5217 if let Some(adt_def) = adt_def {
5218 match adt_def.adt_kind() {
5220 err.help("did you mean to use one of the enum's variants?");
5224 err.span_suggestion(
5226 "use curly brackets",
5227 String::from("Self { /* fields */ }"),
5228 Applicability::HasPlaceholders,
5240 Res::Def(kind, def_id) => {
5241 // The things we are substituting into the type should not contain
5242 // escaping late-bound regions, and nor should the base type scheme.
5243 let ty = tcx.type_of(def_id);
5244 Ok((kind, def_id, ty))
5246 _ => span_bug!(span, "unexpected res in rewrite_self_ctor: {:?}", res),
5251 // Instantiates the given path, which must refer to an item with the given
5252 // number of type parameters and type.
5253 pub fn instantiate_value_path(&self,
5254 segments: &[hir::PathSegment],
5255 self_ty: Option<Ty<'tcx>>,
5259 -> (Ty<'tcx>, Res) {
5261 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5271 Res::Local(hid) | Res::Upvar(hid, ..) => {
5272 let ty = self.local_ty(span, hid).decl_ty;
5273 let ty = self.normalize_associated_types_in(span, &ty);
5274 self.write_ty(hir_id, ty);
5280 let (kind, def_id, ty) = match self.rewrite_self_ctor(res, span) {
5281 Ok(result) => result,
5282 Err(ErrorReported) => return (tcx.types.err, res),
5285 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id);
5287 let mut user_self_ty = None;
5288 let mut is_alias_variant_ctor = false;
5290 DefKind::Ctor(CtorOf::Variant, _) => {
5291 if let Some(self_ty) = self_ty {
5292 let adt_def = self_ty.ty_adt_def().unwrap();
5293 user_self_ty = Some(UserSelfTy {
5294 impl_def_id: adt_def.did,
5297 is_alias_variant_ctor = true;
5301 | DefKind::AssociatedConst => {
5302 let container = tcx.associated_item(def_id).container;
5303 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5305 ty::TraitContainer(trait_did) => {
5306 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5308 ty::ImplContainer(impl_def_id) => {
5309 if segments.len() == 1 {
5310 // `<T>::assoc` will end up here, and so
5311 // can `T::assoc`. It this came from an
5312 // inherent impl, we need to record the
5313 // `T` for posterity (see `UserSelfTy` for
5315 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5316 user_self_ty = Some(UserSelfTy {
5327 // Now that we have categorized what space the parameters for each
5328 // segment belong to, let's sort out the parameters that the user
5329 // provided (if any) into their appropriate spaces. We'll also report
5330 // errors if type parameters are provided in an inappropriate place.
5332 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5333 let generics_has_err = AstConv::prohibit_generics(
5334 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5335 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5341 if generics_has_err {
5342 // Don't try to infer type parameters when prohibited generic arguments were given.
5343 user_self_ty = None;
5346 // Now we have to compare the types that the user *actually*
5347 // provided against the types that were *expected*. If the user
5348 // did not provide any types, then we want to substitute inference
5349 // variables. If the user provided some types, we may still need
5350 // to add defaults. If the user provided *too many* types, that's
5353 let mut infer_args_for_err = FxHashSet::default();
5354 for &PathSeg(def_id, index) in &path_segs {
5355 let seg = &segments[index];
5356 let generics = tcx.generics_of(def_id);
5357 // Argument-position `impl Trait` is treated as a normal generic
5358 // parameter internally, but we don't allow users to specify the
5359 // parameter's value explicitly, so we have to do some error-
5361 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5366 false, // `is_method_call`
5368 if suppress_errors {
5369 infer_args_for_err.insert(index);
5370 self.set_tainted_by_errors(); // See issue #53251.
5374 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5375 tcx.generics_of(*def_id).has_self
5376 }).unwrap_or(false);
5378 let substs = AstConv::create_substs_for_generic_args(
5384 // Provide the generic args, and whether types should be inferred.
5386 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5389 // If we've encountered an `impl Trait`-related error, we're just
5390 // going to infer the arguments for better error messages.
5391 if !infer_args_for_err.contains(&index) {
5392 // Check whether the user has provided generic arguments.
5393 if let Some(ref data) = segments[index].args {
5394 return (Some(data), segments[index].infer_types);
5397 return (None, segments[index].infer_types);
5402 // Provide substitutions for parameters for which (valid) arguments have been provided.
5404 match (¶m.kind, arg) {
5405 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5406 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5408 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5409 self.to_ty(ty).into()
5411 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5412 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5414 _ => unreachable!(),
5417 // Provide substitutions for parameters for which arguments are inferred.
5418 |substs, param, infer_types| {
5420 GenericParamDefKind::Lifetime => {
5421 self.re_infer(span, Some(param)).unwrap().into()
5423 GenericParamDefKind::Type { has_default, .. } => {
5424 if !infer_types && has_default {
5425 // If we have a default, then we it doesn't matter that we're not
5426 // inferring the type arguments: we provide the default where any
5428 let default = tcx.type_of(param.def_id);
5431 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5434 // If no type arguments were provided, we have to infer them.
5435 // This case also occurs as a result of some malformed input, e.g.
5436 // a lifetime argument being given instead of a type parameter.
5437 // Using inference instead of `Error` gives better error messages.
5438 self.var_for_def(span, param)
5441 GenericParamDefKind::Const => {
5442 // FIXME(const_generics:defaults)
5443 // No const parameters were provided, we have to infer them.
5444 self.var_for_def(span, param)
5449 assert!(!substs.has_escaping_bound_vars());
5450 assert!(!ty.has_escaping_bound_vars());
5452 // First, store the "user substs" for later.
5453 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5455 // Add all the obligations that are required, substituting and
5456 // normalized appropriately.
5457 let bounds = self.instantiate_bounds(span, def_id, &substs);
5458 self.add_obligations_for_parameters(
5459 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5462 // Substitute the values for the type parameters into the type of
5463 // the referenced item.
5464 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5466 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5467 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5468 // is inherent, there is no `Self` parameter; instead, the impl needs
5469 // type parameters, which we can infer by unifying the provided `Self`
5470 // with the substituted impl type.
5471 // This also occurs for an enum variant on a type alias.
5472 let ty = tcx.type_of(impl_def_id);
5474 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5475 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5476 Ok(ok) => self.register_infer_ok_obligations(ok),
5478 self.tcx.sess.delay_span_bug(span, &format!(
5479 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5487 self.check_rustc_args_require_const(def_id, hir_id, span);
5489 debug!("instantiate_value_path: type of {:?} is {:?}",
5492 self.write_substs(hir_id, substs);
5494 (ty_substituted, Res::Def(kind, def_id))
5497 fn check_rustc_args_require_const(&self,
5501 // We're only interested in functions tagged with
5502 // #[rustc_args_required_const], so ignore anything that's not.
5503 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5507 // If our calling expression is indeed the function itself, we're good!
5508 // If not, generate an error that this can only be called directly.
5509 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5510 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5512 if let ExprKind::Call(ref callee, ..) = expr.node {
5513 if callee.hir_id == hir_id {
5519 self.tcx.sess.span_err(span, "this function can only be invoked \
5520 directly, not through a function pointer");
5523 // Resolves `typ` by a single level if `typ` is a type variable.
5524 // If no resolution is possible, then an error is reported.
5525 // Numeric inference variables may be left unresolved.
5526 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5527 let ty = self.resolve_type_vars_with_obligations(ty);
5528 if !ty.is_ty_var() {
5531 if !self.is_tainted_by_errors() {
5532 self.need_type_info_err((**self).body_id, sp, ty)
5533 .note("type must be known at this point")
5536 self.demand_suptype(sp, self.tcx.types.err, ty);
5541 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5542 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5543 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5546 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5547 index = enclosing_breakables.stack.len();
5548 enclosing_breakables.by_id.insert(id, index);
5549 enclosing_breakables.stack.push(ctxt);
5553 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5554 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5555 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5556 enclosing_breakables.stack.pop().expect("missing breakable context")
5561 /// Instantiate a QueryResponse in a probe context, without a
5562 /// good ObligationCause.
5563 fn probe_instantiate_query_response(
5566 original_values: &OriginalQueryValues<'tcx>,
5567 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5568 ) -> InferResult<'tcx, Ty<'tcx>>
5570 self.instantiate_query_response_and_region_obligations(
5571 &traits::ObligationCause::misc(span, self.body_id),
5577 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5578 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5579 let mut contained_in_place = false;
5581 while let hir::Node::Expr(parent_expr) =
5582 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5584 match &parent_expr.node {
5585 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5586 if lhs.hir_id == expr_id {
5587 contained_in_place = true;
5593 expr_id = parent_expr.hir_id;
5600 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5601 generics: &ty::Generics,
5603 let own_counts = generics.own_counts();
5605 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5611 if own_counts.types == 0 {
5615 // Make a vector of booleans initially false, set to true when used.
5616 let mut types_used = vec![false; own_counts.types];
5618 for leaf_ty in ty.walk() {
5619 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5620 debug!("Found use of ty param num {}", index);
5621 types_used[index as usize - own_counts.lifetimes] = true;
5622 } else if let ty::Error = leaf_ty.sty {
5623 // If there is already another error, do not emit
5624 // an error for not using a type Parameter.
5625 assert!(tcx.sess.err_count() > 0);
5630 let types = generics.params.iter().filter(|param| match param.kind {
5631 ty::GenericParamDefKind::Type { .. } => true,
5634 for (&used, param) in types_used.iter().zip(types) {
5636 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5637 let span = tcx.hir().span_by_hir_id(id);
5638 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5639 .span_label(span, "unused type parameter")
5645 fn fatally_break_rust(sess: &Session) {
5646 let handler = sess.diagnostic();
5647 handler.span_bug_no_panic(
5649 "It looks like you're trying to break rust; would you like some ICE?",
5651 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5652 handler.note_without_error(
5653 "we would appreciate a joke overview: \
5654 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5656 handler.note_without_error(&format!("rustc {} running on {}",
5657 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5658 crate::session::config::host_triple(),
5662 fn potentially_plural_count(count: usize, word: &str) -> String {
5663 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })