1 // ignore-tidy-filelength
7 Within the check phase of type check, we check each item one at a time
8 (bodies of function expressions are checked as part of the containing
9 function). Inference is used to supply types wherever they are unknown.
11 By far the most complex case is checking the body of a function. This
12 can be broken down into several distinct phases:
14 - gather: creates type variables to represent the type of each local
15 variable and pattern binding.
17 - main: the main pass does the lion's share of the work: it
18 determines the types of all expressions, resolves
19 methods, checks for most invalid conditions, and so forth. In
20 some cases, where a type is unknown, it may create a type or region
21 variable and use that as the type of an expression.
23 In the process of checking, various constraints will be placed on
24 these type variables through the subtyping relationships requested
25 through the `demand` module. The `infer` module is in charge
26 of resolving those constraints.
28 - regionck: after main is complete, the regionck pass goes over all
29 types looking for regions and making sure that they did not escape
30 into places they are not in scope. This may also influence the
31 final assignments of the various region variables if there is some
34 - vtable: find and records the impls to use for each trait bound that
35 appears on a type parameter.
37 - writeback: writes the final types within a function body, replacing
38 type variables with their final inferred types. These final types
39 are written into the `tcx.node_types` table, which should *never* contain
40 any reference to a type variable.
44 While type checking a function, the intermediate types for the
45 expressions, blocks, and so forth contained within the function are
46 stored in `fcx.node_types` and `fcx.node_substs`. These types
47 may contain unresolved type variables. After type checking is
48 complete, the functions in the writeback module are used to take the
49 types from this table, resolve them, and then write them into their
50 permanent home in the type context `tcx`.
52 This means that during inferencing you should use `fcx.write_ty()`
53 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
54 nodes within the function.
56 The types of top-level items, which never contain unbound type
57 variables, are stored directly into the `tcx` tables.
59 N.B., a type variable is not the same thing as a type parameter. A
60 type variable is rather an "instance" of a type parameter: that is,
61 given a generic function `fn foo<T>(t: T)`: while checking the
62 function `foo`, the type `ty_param(0)` refers to the type `T`, which
63 is treated in abstract. When `foo()` is called, however, `T` will be
64 substituted for a fresh type variable `N`. This variable will
65 eventually be resolved to some concrete type (which might itself be
84 mod generator_interior;
88 use crate::astconv::{AstConv, PathSeg};
89 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
90 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
91 use rustc::hir::def::{CtorOf, CtorKind, Res, DefKind};
92 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
93 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
94 use rustc::hir::itemlikevisit::ItemLikeVisitor;
95 use crate::middle::lang_items;
96 use crate::namespace::Namespace;
97 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
98 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
99 use rustc_data_structures::indexed_vec::Idx;
100 use rustc_target::spec::abi::Abi;
101 use rustc::infer::opaque_types::OpaqueTypeDecl;
102 use rustc::infer::type_variable::{TypeVariableOrigin};
103 use rustc::middle::region;
104 use rustc::mir::interpret::{ConstValue, GlobalId};
105 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
107 self, AdtKind, CanonicalUserType, Ty, TyCtxt, GenericParamDefKind, Visibility,
108 ToPolyTraitRef, ToPredicate, RegionKind, UserType
110 use rustc::ty::adjustment::{
111 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
113 use rustc::ty::fold::TypeFoldable;
114 use rustc::ty::query::Providers;
115 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
116 use rustc::ty::util::{Representability, IntTypeExt, Discr};
117 use rustc::ty::layout::VariantIdx;
118 use syntax_pos::{self, BytePos, Span, MultiSpan};
119 use syntax_pos::hygiene::CompilerDesugaringKind;
122 use syntax::feature_gate::{GateIssue, emit_feature_err};
124 use syntax::source_map::{DUMMY_SP, original_sp};
125 use syntax::symbol::{Symbol, LocalInternedString, kw, sym};
126 use syntax::util::lev_distance::find_best_match_for_name;
128 use std::cell::{Cell, RefCell, Ref, RefMut};
129 use std::collections::hash_map::Entry;
131 use std::fmt::Display;
133 use std::mem::replace;
134 use std::ops::{self, Deref};
137 use crate::require_c_abi_if_c_variadic;
138 use crate::session::Session;
139 use crate::session::config::EntryFnType;
140 use crate::TypeAndSubsts;
142 use crate::util::captures::Captures;
143 use crate::util::common::{ErrorReported, indenter};
144 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
146 pub use self::Expectation::*;
147 use self::autoderef::Autoderef;
148 use self::callee::DeferredCallResolution;
149 use self::coercion::{CoerceMany, DynamicCoerceMany};
150 pub use self::compare_method::{compare_impl_method, compare_const_impl};
151 use self::method::{MethodCallee, SelfSource};
152 use self::TupleArgumentsFlag::*;
154 /// The type of a local binding, including the revealed type for anon types.
155 #[derive(Copy, Clone)]
156 pub struct LocalTy<'tcx> {
158 revealed_ty: Ty<'tcx>
161 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
162 #[derive(Copy, Clone)]
163 struct MaybeInProgressTables<'a, 'tcx: 'a> {
164 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
167 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
168 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
177 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
178 match self.maybe_tables {
179 Some(tables) => tables.borrow_mut(),
181 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
187 /// Closures defined within the function. For example:
190 /// bar(move|| { ... })
193 /// Here, the function `foo()` and the closure passed to
194 /// `bar()` will each have their own `FnCtxt`, but they will
195 /// share the inherited fields.
196 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
197 infcx: InferCtxt<'a, 'gcx, 'tcx>,
199 tables: MaybeInProgressTables<'a, 'tcx>,
201 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
203 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
205 // Some additional `Sized` obligations badly affect type inference.
206 // These obligations are added in a later stage of typeck.
207 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
209 // When we process a call like `c()` where `c` is a closure type,
210 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
211 // `FnOnce` closure. In that case, we defer full resolution of the
212 // call until upvar inference can kick in and make the
213 // decision. We keep these deferred resolutions grouped by the
214 // def-id of the closure, so that once we decide, we can easily go
215 // back and process them.
216 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
218 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
220 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
222 // Opaque types found in explicit return types and their
223 // associated fresh inference variable. Writeback resolves these
224 // variables to get the concrete type, which can be used to
225 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
226 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
228 /// Each type parameter has an implicit region bound that
229 /// indicates it must outlive at least the function body (the user
230 /// may specify stronger requirements). This field indicates the
231 /// region of the callee. If it is `None`, then the parameter
232 /// environment is for an item or something where the "callee" is
234 implicit_region_bound: Option<ty::Region<'tcx>>,
236 body_id: Option<hir::BodyId>,
239 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
240 type Target = InferCtxt<'a, 'gcx, 'tcx>;
241 fn deref(&self) -> &Self::Target {
246 /// When type-checking an expression, we propagate downward
247 /// whatever type hint we are able in the form of an `Expectation`.
248 #[derive(Copy, Clone, Debug)]
249 pub enum Expectation<'tcx> {
250 /// We know nothing about what type this expression should have.
253 /// This expression should have the type given (or some subtype).
254 ExpectHasType(Ty<'tcx>),
256 /// This expression will be cast to the `Ty`.
257 ExpectCastableToType(Ty<'tcx>),
259 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
260 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
261 ExpectRvalueLikeUnsized(Ty<'tcx>),
264 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
265 // Disregard "castable to" expectations because they
266 // can lead us astray. Consider for example `if cond
267 // {22} else {c} as u8` -- if we propagate the
268 // "castable to u8" constraint to 22, it will pick the
269 // type 22u8, which is overly constrained (c might not
270 // be a u8). In effect, the problem is that the
271 // "castable to" expectation is not the tightest thing
272 // we can say, so we want to drop it in this case.
273 // The tightest thing we can say is "must unify with
274 // else branch". Note that in the case of a "has type"
275 // constraint, this limitation does not hold.
277 // If the expected type is just a type variable, then don't use
278 // an expected type. Otherwise, we might write parts of the type
279 // when checking the 'then' block which are incompatible with the
281 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
283 ExpectHasType(ety) => {
284 let ety = fcx.shallow_resolve(ety);
285 if !ety.is_ty_var() {
291 ExpectRvalueLikeUnsized(ety) => {
292 ExpectRvalueLikeUnsized(ety)
298 /// Provides an expectation for an rvalue expression given an *optional*
299 /// hint, which is not required for type safety (the resulting type might
300 /// be checked higher up, as is the case with `&expr` and `box expr`), but
301 /// is useful in determining the concrete type.
303 /// The primary use case is where the expected type is a fat pointer,
304 /// like `&[isize]`. For example, consider the following statement:
306 /// let x: &[isize] = &[1, 2, 3];
308 /// In this case, the expected type for the `&[1, 2, 3]` expression is
309 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
310 /// expectation `ExpectHasType([isize])`, that would be too strong --
311 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
312 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
313 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
314 /// which still is useful, because it informs integer literals and the like.
315 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
316 /// for examples of where this comes up,.
317 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
318 match fcx.tcx.struct_tail(ty).sty {
319 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
320 ExpectRvalueLikeUnsized(ty)
322 _ => ExpectHasType(ty)
326 // Resolves `expected` by a single level if it is a variable. If
327 // there is no expected type or resolution is not possible (e.g.,
328 // no constraints yet present), just returns `None`.
329 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
331 NoExpectation => NoExpectation,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
344 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
345 match self.resolve(fcx) {
346 NoExpectation => None,
347 ExpectCastableToType(ty) |
349 ExpectRvalueLikeUnsized(ty) => Some(ty),
353 /// It sometimes happens that we want to turn an expectation into
354 /// a **hard constraint** (i.e., something that must be satisfied
355 /// for the program to type-check). `only_has_type` will return
356 /// such a constraint, if it exists.
357 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 ExpectHasType(ty) => Some(ty),
360 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
364 /// Like `only_has_type`, but instead of returning `None` if no
365 /// hard constraint exists, creates a fresh type variable.
366 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
367 self.only_has_type(fcx)
368 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
372 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
379 fn maybe_mut_place(m: hir::Mutability) -> Self {
381 hir::MutMutable => Needs::MutPlace,
382 hir::MutImmutable => Needs::None,
387 #[derive(Copy, Clone)]
388 pub struct UnsafetyState {
390 pub unsafety: hir::Unsafety,
391 pub unsafe_push_count: u32,
396 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
397 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
400 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
401 match self.unsafety {
402 // If this unsafe, then if the outer function was already marked as
403 // unsafe we shouldn't attribute the unsafe'ness to the block. This
404 // way the block can be warned about instead of ignoring this
405 // extraneous block (functions are never warned about).
406 hir::Unsafety::Unsafe if self.from_fn => *self,
409 let (unsafety, def, count) = match blk.rules {
410 hir::PushUnsafeBlock(..) =>
411 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
412 hir::PopUnsafeBlock(..) =>
413 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
414 hir::UnsafeBlock(..) =>
415 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
417 (unsafety, self.def, self.unsafe_push_count),
421 unsafe_push_count: count,
428 #[derive(Debug, Copy, Clone)]
434 /// Tracks whether executing a node may exit normally (versus
435 /// return/break/panic, which "diverge", leaving dead code in their
436 /// wake). Tracked semi-automatically (through type variables marked
437 /// as diverging), with some manual adjustments for control-flow
438 /// primitives (approximating a CFG).
439 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
441 /// Potentially unknown, some cases converge,
442 /// others require a CFG to determine them.
445 /// Definitely known to diverge and therefore
446 /// not reach the next sibling or its parent.
449 /// Same as `Always` but with a reachability
450 /// warning already emitted.
454 // Convenience impls for combinig `Diverges`.
456 impl ops::BitAnd for Diverges {
458 fn bitand(self, other: Self) -> Self {
459 cmp::min(self, other)
463 impl ops::BitOr for Diverges {
465 fn bitor(self, other: Self) -> Self {
466 cmp::max(self, other)
470 impl ops::BitAndAssign for Diverges {
471 fn bitand_assign(&mut self, other: Self) {
472 *self = *self & other;
476 impl ops::BitOrAssign for Diverges {
477 fn bitor_assign(&mut self, other: Self) {
478 *self = *self | other;
483 fn always(self) -> bool {
484 self >= Diverges::Always
488 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
491 // this is `null` for loops where break with a value is illegal,
492 // such as `while`, `for`, and `while let`
493 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
496 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
497 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
498 by_id: HirIdMap<usize>,
501 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
502 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
503 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
504 bug!("could not find enclosing breakable with id {}", target_id);
510 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
513 /// The parameter environment used for proving trait obligations
514 /// in this function. This can change when we descend into
515 /// closures (as they bring new things into scope), hence it is
516 /// not part of `Inherited` (as of the time of this writing,
517 /// closures do not yet change the environment, but they will
519 param_env: ty::ParamEnv<'tcx>,
521 // Number of errors that had been reported when we started
522 // checking this function. On exit, if we find that *more* errors
523 // have been reported, we will skip regionck and other work that
524 // expects the types within the function to be consistent.
525 err_count_on_creation: usize,
527 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
528 ret_coercion_span: RefCell<Option<Span>>,
530 yield_ty: Option<Ty<'tcx>>,
532 ps: RefCell<UnsafetyState>,
534 /// Whether the last checked node generates a divergence (e.g.,
535 /// `return` will set this to `Always`). In general, when entering
536 /// an expression or other node in the tree, the initial value
537 /// indicates whether prior parts of the containing expression may
538 /// have diverged. It is then typically set to `Maybe` (and the
539 /// old value remembered) for processing the subparts of the
540 /// current expression. As each subpart is processed, they may set
541 /// the flag to `Always`, etc. Finally, at the end, we take the
542 /// result and "union" it with the original value, so that when we
543 /// return the flag indicates if any subpart of the parent
544 /// expression (up to and including this part) has diverged. So,
545 /// if you read it after evaluating a subexpression `X`, the value
546 /// you get indicates whether any subexpression that was
547 /// evaluating up to and including `X` diverged.
549 /// We currently use this flag only for diagnostic purposes:
551 /// - To warn about unreachable code: if, after processing a
552 /// sub-expression but before we have applied the effects of the
553 /// current node, we see that the flag is set to `Always`, we
554 /// can issue a warning. This corresponds to something like
555 /// `foo(return)`; we warn on the `foo()` expression. (We then
556 /// update the flag to `WarnedAlways` to suppress duplicate
557 /// reports.) Similarly, if we traverse to a fresh statement (or
558 /// tail expression) from a `Always` setting, we will issue a
559 /// warning. This corresponds to something like `{return;
560 /// foo();}` or `{return; 22}`, where we would warn on the
563 /// An expression represents dead code if, after checking it,
564 /// the diverges flag is set to something other than `Maybe`.
565 diverges: Cell<Diverges>,
567 /// Whether any child nodes have any type errors.
568 has_errors: Cell<bool>,
570 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
572 inh: &'a Inherited<'a, 'gcx, 'tcx>,
575 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
576 type Target = Inherited<'a, 'gcx, 'tcx>;
577 fn deref(&self) -> &Self::Target {
582 /// Helper type of a temporary returned by `Inherited::build(...)`.
583 /// Necessary because we can't write the following bound:
584 /// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
585 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
586 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
590 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
591 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
592 -> InheritedBuilder<'a, 'gcx, 'tcx> {
593 let hir_id_root = if def_id.is_local() {
594 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
595 DefId::local(hir_id.owner)
601 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
607 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
608 fn enter<F, R>(&'tcx mut self, f: F) -> R
609 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
611 let def_id = self.def_id;
612 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
616 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
617 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
619 let item_id = tcx.hir().as_local_hir_id(def_id);
620 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
621 let implicit_region_bound = body_id.map(|body_id| {
622 let body = tcx.hir().body(body_id);
623 tcx.mk_region(ty::ReScope(region::Scope {
624 id: body.value.hir_id.local_id,
625 data: region::ScopeData::CallSite
630 tables: MaybeInProgressTables {
631 maybe_tables: infcx.in_progress_tables,
634 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
635 locals: RefCell::new(Default::default()),
636 deferred_sized_obligations: RefCell::new(Vec::new()),
637 deferred_call_resolutions: RefCell::new(Default::default()),
638 deferred_cast_checks: RefCell::new(Vec::new()),
639 deferred_generator_interiors: RefCell::new(Vec::new()),
640 opaque_types: RefCell::new(Default::default()),
641 implicit_region_bound,
646 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
647 debug!("register_predicate({:?})", obligation);
648 if obligation.has_escaping_bound_vars() {
649 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
654 .register_predicate_obligation(self, obligation);
657 fn register_predicates<I>(&self, obligations: I)
658 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
660 for obligation in obligations {
661 self.register_predicate(obligation);
665 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
666 self.register_predicates(infer_ok.obligations);
670 fn normalize_associated_types_in<T>(&self,
673 param_env: ty::ParamEnv<'tcx>,
675 where T : TypeFoldable<'tcx>
677 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
678 self.register_infer_ok_obligations(ok)
682 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
684 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
685 fn visit_item(&mut self, i: &'tcx hir::Item) {
686 check_item_type(self.tcx, i);
688 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
689 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
692 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
693 tcx.sess.track_errors(|| {
694 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
695 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
699 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
700 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
703 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) {
704 debug_assert!(crate_num == LOCAL_CRATE);
705 tcx.par_body_owners(|body_owner_def_id| {
706 tcx.ensure().typeck_tables_of(body_owner_def_id);
710 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
711 wfcheck::check_item_well_formed(tcx, def_id);
714 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
715 wfcheck::check_trait_item(tcx, def_id);
718 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
719 wfcheck::check_impl_item(tcx, def_id);
722 pub fn provide(providers: &mut Providers<'_>) {
723 method::provide(providers);
724 *providers = Providers {
730 check_item_well_formed,
731 check_trait_item_well_formed,
732 check_impl_item_well_formed,
733 check_mod_item_types,
738 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
740 -> Option<ty::Destructor> {
741 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
744 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
745 /// with information about it's body-id and fn-decl (if any). Otherwise,
748 /// If this function returns "some", then `typeck_tables(def_id)` will
749 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
750 /// may not succeed. In some cases where this function returns `None`
751 /// (notably closures), `typeck_tables(def_id)` would wind up
752 /// redirecting to the owning function.
753 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
755 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
757 match tcx.hir().get_by_hir_id(id) {
758 Node::Item(item) => {
760 hir::ItemKind::Const(_, body) |
761 hir::ItemKind::Static(_, _, body) =>
763 hir::ItemKind::Fn(ref decl, .., body) =>
764 Some((body, Some(decl))),
769 Node::TraitItem(item) => {
771 hir::TraitItemKind::Const(_, Some(body)) =>
773 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
774 Some((body, Some(&sig.decl))),
779 Node::ImplItem(item) => {
781 hir::ImplItemKind::Const(_, body) =>
783 hir::ImplItemKind::Method(ref sig, body) =>
784 Some((body, Some(&sig.decl))),
789 Node::AnonConst(constant) => Some((constant.body, None)),
794 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
797 // Closures' tables come from their outermost function,
798 // as they are part of the same "inference environment".
799 let outer_def_id = tcx.closure_base_def_id(def_id);
800 if outer_def_id != def_id {
801 return tcx.has_typeck_tables(outer_def_id);
804 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
805 primary_body_of(tcx, id).is_some()
808 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
811 &*tcx.typeck_tables_of(def_id).used_trait_imports
814 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
816 -> &'tcx ty::TypeckTables<'tcx> {
817 // Closures' tables come from their outermost function,
818 // as they are part of the same "inference environment".
819 let outer_def_id = tcx.closure_base_def_id(def_id);
820 if outer_def_id != def_id {
821 return tcx.typeck_tables_of(outer_def_id);
824 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
825 let span = tcx.hir().span_by_hir_id(id);
827 // Figure out what primary body this item has.
828 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
829 span_bug!(span, "can't type-check body of {:?}", def_id);
831 let body = tcx.hir().body(body_id);
833 let tables = Inherited::build(tcx, def_id).enter(|inh| {
834 let param_env = tcx.param_env(def_id);
835 let fcx = if let Some(decl) = fn_decl {
836 let fn_sig = tcx.fn_sig(def_id);
838 check_abi(tcx, span, fn_sig.abi());
840 // Compute the fty from point of view of inside the fn.
842 tcx.liberate_late_bound_regions(def_id, &fn_sig);
844 inh.normalize_associated_types_in(body.value.span,
849 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
852 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
853 let expected_type = tcx.type_of(def_id);
854 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
855 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
857 let revealed_ty = if tcx.features().impl_trait_in_bindings {
858 fcx.instantiate_opaque_types_from_value(
866 // Gather locals in statics (because of block expressions).
867 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
871 fcx.write_ty(id, revealed_ty);
876 // All type checking constraints were added, try to fallback unsolved variables.
877 fcx.select_obligations_where_possible(false);
878 let mut fallback_has_occurred = false;
879 for ty in &fcx.unsolved_variables() {
880 fallback_has_occurred |= fcx.fallback_if_possible(ty);
882 fcx.select_obligations_where_possible(fallback_has_occurred);
884 // Even though coercion casts provide type hints, we check casts after fallback for
885 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
888 // Closure and generator analysis may run after fallback
889 // because they don't constrain other type variables.
890 fcx.closure_analyze(body);
891 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
892 fcx.resolve_generator_interiors(def_id);
894 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
895 let ty = fcx.normalize_ty(span, ty);
896 fcx.require_type_is_sized(ty, span, code);
898 fcx.select_all_obligations_or_error();
900 if fn_decl.is_some() {
901 fcx.regionck_fn(id, body);
903 fcx.regionck_expr(body);
906 fcx.resolve_type_vars_in_body(body)
909 // Consistency check our TypeckTables instance can hold all ItemLocalIds
910 // it will need to hold.
911 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
916 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
917 if !tcx.sess.target.target.is_abi_supported(abi) {
918 struct_span_err!(tcx.sess, span, E0570,
919 "The ABI `{}` is not supported for the current target", abi).emit()
923 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
924 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
929 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
934 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
941 // take type that the user specified
942 self.fcx.locals.borrow_mut().insert(nid, typ);
949 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
950 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
951 NestedVisitorMap::None
954 // Add explicitly-declared locals.
955 fn visit_local(&mut self, local: &'gcx hir::Local) {
956 let local_ty = match local.ty {
958 let o_ty = self.fcx.to_ty(&ty);
960 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
961 self.fcx.instantiate_opaque_types_from_value(
969 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
970 &UserType::Ty(revealed_ty)
972 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
973 ty.hir_id, o_ty, revealed_ty, c_ty);
974 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
976 Some(LocalTy { decl_ty: o_ty, revealed_ty })
980 self.assign(local.span, local.hir_id, local_ty);
982 debug!("Local variable {:?} is assigned type {}",
984 self.fcx.ty_to_string(
985 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
986 intravisit::walk_local(self, local);
989 // Add pattern bindings.
990 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
991 if let PatKind::Binding(_, _, ident, _) = p.node {
992 let var_ty = self.assign(p.span, p.hir_id, None);
994 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
995 if !self.fcx.tcx.features().unsized_locals {
996 self.fcx.require_type_is_sized(var_ty, p.span,
997 traits::VariableType(node_id));
1000 debug!("Pattern binding {} is assigned to {} with type {:?}",
1002 self.fcx.ty_to_string(
1003 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1006 intravisit::walk_pat(self, p);
1009 // Don't descend into the bodies of nested closures
1010 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1011 _: hir::BodyId, _: Span, _: hir::HirId) { }
1013 fn visit_argument_source(&mut self, s: &'gcx hir::ArgSource) {
1015 // Don't visit the pattern in `ArgSource::AsyncFn`, it contains a pattern which has
1016 // a `NodeId` w/out a type, as it is only used for getting the name of the original
1017 // pattern for diagnostics where only an `hir::Arg` is present.
1018 hir::ArgSource::AsyncFn(..) => {},
1019 _ => intravisit::walk_argument_source(self, s),
1024 /// When `check_fn` is invoked on a generator (i.e., a body that
1025 /// includes yield), it returns back some information about the yield
1027 struct GeneratorTypes<'tcx> {
1028 /// Type of value that is yielded.
1031 /// Types that are captured (see `GeneratorInterior` for more).
1034 /// Indicates if the generator is movable or static (immovable).
1035 movability: hir::GeneratorMovability,
1038 /// Helper used for fns and closures. Does the grungy work of checking a function
1039 /// body and returns the function context used for that purpose, since in the case of a fn item
1040 /// there is still a bit more to do.
1043 /// * inherited: other fields inherited from the enclosing fn (if any)
1044 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1045 param_env: ty::ParamEnv<'tcx>,
1046 fn_sig: ty::FnSig<'tcx>,
1047 decl: &'gcx hir::FnDecl,
1049 body: &'gcx hir::Body,
1050 can_be_generator: Option<hir::GeneratorMovability>)
1051 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1053 let mut fn_sig = fn_sig.clone();
1055 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1057 // Create the function context. This is either derived from scratch or,
1058 // in the case of closures, based on the outer context.
1059 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1060 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1062 let declared_ret_ty = fn_sig.output();
1063 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1064 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1065 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1066 fn_sig = fcx.tcx.mk_fn_sig(
1067 fn_sig.inputs().iter().cloned(),
1074 let span = body.value.span;
1076 if body.is_generator && can_be_generator.is_some() {
1077 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1078 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1079 fcx.yield_ty = Some(yield_ty);
1082 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1083 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1084 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1086 // Add formal parameters.
1087 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1088 // Check the pattern.
1089 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1090 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1092 // Check that argument is Sized.
1093 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1094 // for simple cases like `fn foo(x: Trait)`,
1095 // where we would error once on the parameter as a whole, and once on the binding `x`.
1096 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1097 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1100 fcx.write_ty(arg.hir_id, arg_ty);
1103 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1105 fcx.check_return_expr(&body.value);
1107 // We insert the deferred_generator_interiors entry after visiting the body.
1108 // This ensures that all nested generators appear before the entry of this generator.
1109 // resolve_generator_interiors relies on this property.
1110 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1111 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1112 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1113 Some(GeneratorTypes {
1114 yield_ty: fcx.yield_ty.unwrap(),
1116 movability: can_be_generator.unwrap(),
1122 // Finalize the return check by taking the LUB of the return types
1123 // we saw and assigning it to the expected return type. This isn't
1124 // really expected to fail, since the coercions would have failed
1125 // earlier when trying to find a LUB.
1127 // However, the behavior around `!` is sort of complex. In the
1128 // event that the `actual_return_ty` comes back as `!`, that
1129 // indicates that the fn either does not return or "returns" only
1130 // values of type `!`. In this case, if there is an expected
1131 // return type that is *not* `!`, that should be ok. But if the
1132 // return type is being inferred, we want to "fallback" to `!`:
1134 // let x = move || panic!();
1136 // To allow for that, I am creating a type variable with diverging
1137 // fallback. This was deemed ever so slightly better than unifying
1138 // the return value with `!` because it allows for the caller to
1139 // make more assumptions about the return type (e.g., they could do
1141 // let y: Option<u32> = Some(x());
1143 // which would then cause this return type to become `u32`, not
1145 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1146 let mut actual_return_ty = coercion.complete(&fcx);
1147 if actual_return_ty.is_never() {
1148 actual_return_ty = fcx.next_diverging_ty_var(
1149 TypeVariableOrigin::DivergingFn(span));
1151 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1153 // Check that the main return type implements the termination trait.
1154 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1155 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1156 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1157 if main_id == fn_id {
1158 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1159 let trait_ref = ty::TraitRef::new(term_id, substs);
1160 let return_ty_span = decl.output.span();
1161 let cause = traits::ObligationCause::new(
1162 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1164 inherited.register_predicate(
1165 traits::Obligation::new(
1166 cause, param_env, trait_ref.to_predicate()));
1171 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1172 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1173 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1174 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1175 // at this point we don't care if there are duplicate handlers or if the handler has
1176 // the wrong signature as this value we'll be used when writing metadata and that
1177 // only happens if compilation succeeded
1178 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1180 if declared_ret_ty.sty != ty::Never {
1181 fcx.tcx.sess.span_err(
1183 "return type should be `!`",
1187 let inputs = fn_sig.inputs();
1188 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1189 if inputs.len() == 1 {
1190 let arg_is_panic_info = match inputs[0].sty {
1191 ty::Ref(region, ty, mutbl) => match ty.sty {
1192 ty::Adt(ref adt, _) => {
1193 adt.did == panic_info_did &&
1194 mutbl == hir::Mutability::MutImmutable &&
1195 *region != RegionKind::ReStatic
1202 if !arg_is_panic_info {
1203 fcx.tcx.sess.span_err(
1204 decl.inputs[0].span,
1205 "argument should be `&PanicInfo`",
1209 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1210 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1211 if !generics.params.is_empty() {
1212 fcx.tcx.sess.span_err(
1214 "should have no type parameters",
1220 let span = fcx.tcx.sess.source_map().def_span(span);
1221 fcx.tcx.sess.span_err(span, "function should have one argument");
1224 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1229 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1230 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1231 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1232 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1233 if declared_ret_ty.sty != ty::Never {
1234 fcx.tcx.sess.span_err(
1236 "return type should be `!`",
1240 let inputs = fn_sig.inputs();
1241 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1242 if inputs.len() == 1 {
1243 let arg_is_alloc_layout = match inputs[0].sty {
1244 ty::Adt(ref adt, _) => {
1245 adt.did == alloc_layout_did
1250 if !arg_is_alloc_layout {
1251 fcx.tcx.sess.span_err(
1252 decl.inputs[0].span,
1253 "argument should be `Layout`",
1257 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1258 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1259 if !generics.params.is_empty() {
1260 fcx.tcx.sess.span_err(
1262 "`#[alloc_error_handler]` function should have no type \
1269 let span = fcx.tcx.sess.source_map().def_span(span);
1270 fcx.tcx.sess.span_err(span, "function should have one argument");
1273 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1281 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1284 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1285 let def = tcx.adt_def(def_id);
1286 def.destructor(tcx); // force the destructor to be evaluated
1287 check_representable(tcx, span, def_id);
1289 if def.repr.simd() {
1290 check_simd(tcx, span, def_id);
1293 check_transparent(tcx, span, def_id);
1294 check_packed(tcx, span, def_id);
1297 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1300 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1301 let def = tcx.adt_def(def_id);
1302 def.destructor(tcx); // force the destructor to be evaluated
1303 check_representable(tcx, span, def_id);
1305 check_packed(tcx, span, def_id);
1308 fn check_opaque<'a, 'tcx>(
1309 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1311 substs: SubstsRef<'tcx>,
1314 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1315 let mut err = struct_span_err!(
1316 tcx.sess, span, E0720,
1317 "opaque type expands to a recursive type",
1319 err.span_label(span, "expands to self-referential type");
1320 if let ty::Opaque(..) = partially_expanded_type.sty {
1321 err.note("type resolves to itself");
1323 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1329 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1331 "check_item_type(it.hir_id={}, it.name={})",
1333 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1335 let _indenter = indenter();
1337 // Consts can play a role in type-checking, so they are included here.
1338 hir::ItemKind::Static(..) => {
1339 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1340 tcx.typeck_tables_of(def_id);
1341 maybe_check_static_with_link_section(tcx, def_id, it.span);
1343 hir::ItemKind::Const(..) => {
1344 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1346 hir::ItemKind::Enum(ref enum_definition, _) => {
1347 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1349 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1350 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1351 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1352 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1353 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1354 check_impl_items_against_trait(
1361 let trait_def_id = impl_trait_ref.def_id;
1362 check_on_unimplemented(tcx, trait_def_id, it);
1365 hir::ItemKind::Trait(..) => {
1366 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1367 check_on_unimplemented(tcx, def_id, it);
1369 hir::ItemKind::Struct(..) => {
1370 check_struct(tcx, it.hir_id, it.span);
1372 hir::ItemKind::Union(..) => {
1373 check_union(tcx, it.hir_id, it.span);
1375 hir::ItemKind::Existential(..) => {
1376 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1378 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1379 check_opaque(tcx, def_id, substs, it.span);
1381 hir::ItemKind::Ty(..) => {
1382 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1383 let pty_ty = tcx.type_of(def_id);
1384 let generics = tcx.generics_of(def_id);
1385 check_bounds_are_used(tcx, &generics, pty_ty);
1387 hir::ItemKind::ForeignMod(ref m) => {
1388 check_abi(tcx, it.span, m.abi);
1390 if m.abi == Abi::RustIntrinsic {
1391 for item in &m.items {
1392 intrinsic::check_intrinsic_type(tcx, item);
1394 } else if m.abi == Abi::PlatformIntrinsic {
1395 for item in &m.items {
1396 intrinsic::check_platform_intrinsic_type(tcx, item);
1399 for item in &m.items {
1400 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1401 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1402 let mut err = struct_span_err!(
1406 "foreign items may not have type parameters"
1408 err.span_label(item.span, "can't have type parameters");
1409 // FIXME: once we start storing spans for type arguments, turn this into a
1412 "use specialization instead of type parameters by replacing them \
1413 with concrete types like `u32`",
1418 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1419 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1424 _ => { /* nothing to do */ }
1428 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1429 // Only restricted on wasm32 target for now
1430 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1434 // If `#[link_section]` is missing, then nothing to verify
1435 let attrs = tcx.codegen_fn_attrs(id);
1436 if attrs.link_section.is_none() {
1440 // For the wasm32 target statics with #[link_section] are placed into custom
1441 // sections of the final output file, but this isn't link custom sections of
1442 // other executable formats. Namely we can only embed a list of bytes,
1443 // nothing with pointers to anything else or relocations. If any relocation
1444 // show up, reject them here.
1445 let instance = ty::Instance::mono(tcx, id);
1446 let cid = GlobalId {
1450 let param_env = ty::ParamEnv::reveal_all();
1451 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1452 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1455 bug!("Matching on non-ByRef static")
1457 if alloc.relocations.len() != 0 {
1458 let msg = "statics with a custom `#[link_section]` must be a \
1459 simple list of bytes on the wasm target with no \
1460 extra levels of indirection such as references";
1461 tcx.sess.span_err(span, msg);
1466 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1467 trait_def_id: DefId,
1469 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1470 // an error would be reported if this fails.
1471 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1474 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1475 impl_item: &hir::ImplItem,
1478 let mut err = struct_span_err!(
1479 tcx.sess, impl_item.span, E0520,
1480 "`{}` specializes an item from a parent `impl`, but \
1481 that item is not marked `default`",
1483 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1486 match tcx.span_of_impl(parent_impl) {
1488 err.span_label(span, "parent `impl` is here");
1489 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1493 err.note(&format!("parent implementation is in crate `{}`", cname));
1500 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1501 trait_def: &ty::TraitDef,
1502 trait_item: &ty::AssocItem,
1504 impl_item: &hir::ImplItem)
1506 let ancestors = trait_def.ancestors(tcx, impl_id);
1508 let kind = match impl_item.node {
1509 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1510 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1511 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1512 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1515 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1516 .map(|node_item| node_item.map(|parent| parent.defaultness));
1518 if let Some(parent) = parent {
1519 if tcx.impl_item_is_final(&parent) {
1520 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1526 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1529 impl_trait_ref: ty::TraitRef<'tcx>,
1530 impl_item_refs: &[hir::ImplItemRef]) {
1531 let impl_span = tcx.sess.source_map().def_span(impl_span);
1533 // If the trait reference itself is erroneous (so the compilation is going
1534 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1535 // isn't populated for such impls.
1536 if impl_trait_ref.references_error() { return; }
1538 // Locate trait definition and items
1539 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1540 let mut overridden_associated_type = None;
1542 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1544 // Check existing impl methods to see if they are both present in trait
1545 // and compatible with trait signature
1546 for impl_item in impl_items() {
1547 let ty_impl_item = tcx.associated_item(
1548 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1549 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1550 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1551 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1553 // Not compatible, but needed for the error message
1554 tcx.associated_items(impl_trait_ref.def_id)
1555 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1558 // Check that impl definition matches trait definition
1559 if let Some(ty_trait_item) = ty_trait_item {
1560 match impl_item.node {
1561 hir::ImplItemKind::Const(..) => {
1562 // Find associated const definition.
1563 if ty_trait_item.kind == ty::AssocKind::Const {
1564 compare_const_impl(tcx,
1570 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1571 "item `{}` is an associated const, \
1572 which doesn't match its trait `{}`",
1575 err.span_label(impl_item.span, "does not match trait");
1576 // We can only get the spans from local trait definition
1577 // Same for E0324 and E0325
1578 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1579 err.span_label(trait_span, "item in trait");
1584 hir::ImplItemKind::Method(..) => {
1585 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1586 if ty_trait_item.kind == ty::AssocKind::Method {
1587 compare_impl_method(tcx,
1594 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1595 "item `{}` is an associated method, \
1596 which doesn't match its trait `{}`",
1599 err.span_label(impl_item.span, "does not match trait");
1600 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1601 err.span_label(trait_span, "item in trait");
1606 hir::ImplItemKind::Existential(..) |
1607 hir::ImplItemKind::Type(_) => {
1608 if ty_trait_item.kind == ty::AssocKind::Type {
1609 if ty_trait_item.defaultness.has_value() {
1610 overridden_associated_type = Some(impl_item);
1613 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1614 "item `{}` is an associated type, \
1615 which doesn't match its trait `{}`",
1618 err.span_label(impl_item.span, "does not match trait");
1619 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1620 err.span_label(trait_span, "item in trait");
1627 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1631 // Check for missing items from trait
1632 let mut missing_items = Vec::new();
1633 let mut invalidated_items = Vec::new();
1634 let associated_type_overridden = overridden_associated_type.is_some();
1635 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1636 let is_implemented = trait_def.ancestors(tcx, impl_id)
1637 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1639 .map(|node_item| !node_item.node.is_from_trait())
1642 if !is_implemented && !tcx.impl_is_default(impl_id) {
1643 if !trait_item.defaultness.has_value() {
1644 missing_items.push(trait_item);
1645 } else if associated_type_overridden {
1646 invalidated_items.push(trait_item.ident);
1651 if !missing_items.is_empty() {
1652 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1653 "not all trait items implemented, missing: `{}`",
1654 missing_items.iter()
1655 .map(|trait_item| trait_item.ident.to_string())
1656 .collect::<Vec<_>>().join("`, `"));
1657 err.span_label(impl_span, format!("missing `{}` in implementation",
1658 missing_items.iter()
1659 .map(|trait_item| trait_item.ident.to_string())
1660 .collect::<Vec<_>>().join("`, `")));
1661 for trait_item in missing_items {
1662 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1663 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1665 err.note_trait_signature(trait_item.ident.to_string(),
1666 trait_item.signature(tcx));
1672 if !invalidated_items.is_empty() {
1673 let invalidator = overridden_associated_type.unwrap();
1674 span_err!(tcx.sess, invalidator.span, E0399,
1675 "the following trait items need to be reimplemented \
1676 as `{}` was overridden: `{}`",
1678 invalidated_items.iter()
1679 .map(|name| name.to_string())
1680 .collect::<Vec<_>>().join("`, `"))
1684 /// Checks whether a type can be represented in memory. In particular, it
1685 /// identifies types that contain themselves without indirection through a
1686 /// pointer, which would mean their size is unbounded.
1687 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1691 let rty = tcx.type_of(item_def_id);
1693 // Check that it is possible to represent this type. This call identifies
1694 // (1) types that contain themselves and (2) types that contain a different
1695 // recursive type. It is only necessary to throw an error on those that
1696 // contain themselves. For case 2, there must be an inner type that will be
1697 // caught by case 1.
1698 match rty.is_representable(tcx, sp) {
1699 Representability::SelfRecursive(spans) => {
1700 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1702 err.span_label(span, "recursive without indirection");
1707 Representability::Representable | Representability::ContainsRecursive => (),
1712 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1713 let t = tcx.type_of(def_id);
1714 if let ty::Adt(def, substs) = t.sty {
1715 if def.is_struct() {
1716 let fields = &def.non_enum_variant().fields;
1717 if fields.is_empty() {
1718 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1721 let e = fields[0].ty(tcx, substs);
1722 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1723 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1724 .span_label(sp, "SIMD elements must have the same type")
1729 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1730 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1732 span_err!(tcx.sess, sp, E0077,
1733 "SIMD vector element type should be machine type");
1741 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1742 let repr = tcx.adt_def(def_id).repr;
1744 for attr in tcx.get_attrs(def_id).iter() {
1745 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1746 if let attr::ReprPacked(pack) = r {
1747 if pack != repr.pack {
1748 struct_span_err!(tcx.sess, sp, E0634,
1749 "type has conflicting packed representation hints").emit();
1755 struct_span_err!(tcx.sess, sp, E0587,
1756 "type has conflicting packed and align representation hints").emit();
1758 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1759 struct_span_err!(tcx.sess, sp, E0588,
1760 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1765 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1767 stack: &mut Vec<DefId>) -> bool {
1768 let t = tcx.type_of(def_id);
1769 if stack.contains(&def_id) {
1770 debug!("check_packed_inner: {:?} is recursive", t);
1773 if let ty::Adt(def, substs) = t.sty {
1774 if def.is_struct() || def.is_union() {
1775 if tcx.adt_def(def.did).repr.align > 0 {
1778 // push struct def_id before checking fields
1780 for field in &def.non_enum_variant().fields {
1781 let f = field.ty(tcx, substs);
1782 if let ty::Adt(def, _) = f.sty {
1783 if check_packed_inner(tcx, def.did, stack) {
1788 // only need to pop if not early out
1795 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1796 let adt = tcx.adt_def(def_id);
1797 if !adt.repr.transparent() {
1801 // For each field, figure out if it's known to be a ZST and align(1)
1802 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1803 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1804 let param_env = tcx.param_env(field.did);
1805 let layout = tcx.layout_of(param_env.and(ty));
1806 // We are currently checking the type this field came from, so it must be local
1807 let span = tcx.hir().span_if_local(field.did).unwrap();
1808 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1809 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1813 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1814 let non_zst_count = non_zst_fields.clone().count();
1815 if non_zst_count != 1 {
1816 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1817 struct_span_err!(tcx.sess, sp, E0690,
1818 "transparent struct needs exactly one non-zero-sized field, but has {}",
1820 .span_note(field_spans, "non-zero-sized field")
1823 for (span, zst, align1) in field_infos {
1825 span_err!(tcx.sess, span, E0691,
1826 "zero-sized field in transparent struct has alignment larger than 1");
1831 #[allow(trivial_numeric_casts)]
1832 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1834 vs: &'tcx [hir::Variant],
1836 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1837 let def = tcx.adt_def(def_id);
1838 def.destructor(tcx); // force the destructor to be evaluated
1841 let attributes = tcx.get_attrs(def_id);
1842 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1844 tcx.sess, attr.span, E0084,
1845 "unsupported representation for zero-variant enum")
1846 .span_label(sp, "zero-variant enum")
1851 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1852 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1853 if !tcx.features().repr128 {
1854 emit_feature_err(&tcx.sess.parse_sess,
1857 GateIssue::Language,
1858 "repr with 128-bit type is unstable");
1863 if let Some(ref e) = v.node.disr_expr {
1864 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1868 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1869 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1870 // Check for duplicate discriminant values
1871 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1872 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1873 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1874 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1875 let i_span = match variant_i.node.disr_expr {
1876 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1877 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1879 let span = match v.node.disr_expr {
1880 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1883 struct_span_err!(tcx.sess, span, E0081,
1884 "discriminant value `{}` already exists", disr_vals[i])
1885 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1886 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1889 disr_vals.push(discr);
1892 check_representable(tcx, sp, def_id);
1895 fn report_unexpected_variant_res<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1899 span_err!(tcx.sess, span, E0533,
1900 "expected unit struct/variant or constant, found {} `{}`",
1902 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1905 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1906 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1908 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1909 -> &'tcx ty::GenericPredicates<'tcx>
1912 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1913 let item_id = tcx.hir().ty_param_owner(hir_id);
1914 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1915 let generics = tcx.generics_of(item_def_id);
1916 let index = generics.param_def_id_to_index[&def_id];
1917 tcx.arena.alloc(ty::GenericPredicates {
1919 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1921 ty::Predicate::Trait(ref data)
1922 if data.skip_binder().self_ty().is_param(index) => {
1923 // HACK(eddyb) should get the original `Span`.
1924 let span = tcx.def_span(def_id);
1925 Some((predicate, span))
1933 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1934 -> Option<ty::Region<'tcx>> {
1936 Some(def) => infer::EarlyBoundRegion(span, def.name),
1937 None => infer::MiscVariable(span)
1939 Some(self.next_region_var(v))
1942 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1943 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1946 fn ty_infer_for_def(&self,
1947 ty_param_def: &ty::GenericParamDef,
1948 span: Span) -> Ty<'tcx> {
1949 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1955 fn projected_ty_from_poly_trait_ref(&self,
1958 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1961 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1963 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1967 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1970 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1971 if ty.has_escaping_bound_vars() {
1972 ty // FIXME: normalization and escaping regions
1974 self.normalize_associated_types_in(span, &ty)
1978 fn set_tainted_by_errors(&self) {
1979 self.infcx.set_tainted_by_errors()
1982 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1983 self.write_ty(hir_id, ty)
1987 /// Controls whether the arguments are tupled. This is used for the call
1990 /// Tupling means that all call-side arguments are packed into a tuple and
1991 /// passed as a single parameter. For example, if tupling is enabled, this
1994 /// fn f(x: (isize, isize))
1996 /// Can be called as:
2003 #[derive(Clone, Eq, PartialEq)]
2004 enum TupleArgumentsFlag {
2009 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2010 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2011 param_env: ty::ParamEnv<'tcx>,
2012 body_id: hir::HirId)
2013 -> FnCtxt<'a, 'gcx, 'tcx> {
2017 err_count_on_creation: inh.tcx.sess.err_count(),
2019 ret_coercion_span: RefCell::new(None),
2021 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2022 hir::CRATE_HIR_ID)),
2023 diverges: Cell::new(Diverges::Maybe),
2024 has_errors: Cell::new(false),
2025 enclosing_breakables: RefCell::new(EnclosingBreakables {
2027 by_id: Default::default(),
2033 pub fn sess(&self) -> &Session {
2037 pub fn err_count_since_creation(&self) -> usize {
2038 self.tcx.sess.err_count() - self.err_count_on_creation
2041 /// Produces warning on the given node, if the current point in the
2042 /// function is unreachable, and there hasn't been another warning.
2043 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2044 if self.diverges.get() == Diverges::Always &&
2045 // If span arose from a desugaring of `if` then it is the condition itself,
2046 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2047 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2048 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2049 self.diverges.set(Diverges::WarnedAlways);
2051 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2053 let msg = format!("unreachable {}", kind);
2054 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2060 code: ObligationCauseCode<'tcx>)
2061 -> ObligationCause<'tcx> {
2062 ObligationCause::new(span, self.body_id, code)
2065 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2066 self.cause(span, ObligationCauseCode::MiscObligation)
2069 /// Resolves type variables in `ty` if possible. Unlike the infcx
2070 /// version (resolve_vars_if_possible), this version will
2071 /// also select obligations if it seems useful, in an effort
2072 /// to get more type information.
2073 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2074 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2076 // No Infer()? Nothing needs doing.
2077 if !ty.has_infer_types() {
2078 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2082 // If `ty` is a type variable, see whether we already know what it is.
2083 ty = self.resolve_vars_if_possible(&ty);
2084 if !ty.has_infer_types() {
2085 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2089 // If not, try resolving pending obligations as much as
2090 // possible. This can help substantially when there are
2091 // indirect dependencies that don't seem worth tracking
2093 self.select_obligations_where_possible(false);
2094 ty = self.resolve_vars_if_possible(&ty);
2096 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2100 fn record_deferred_call_resolution(&self,
2101 closure_def_id: DefId,
2102 r: DeferredCallResolution<'gcx, 'tcx>) {
2103 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2104 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2107 fn remove_deferred_call_resolutions(&self,
2108 closure_def_id: DefId)
2109 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2111 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2112 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2115 pub fn tag(&self) -> String {
2116 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2117 format!("{:?}", self_ptr)
2120 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2121 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2122 span_bug!(span, "no type for local variable {}",
2123 self.tcx.hir().hir_to_string(nid))
2128 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2129 debug!("write_ty({:?}, {:?}) in fcx {}",
2130 id, self.resolve_vars_if_possible(&ty), self.tag());
2131 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2133 if ty.references_error() {
2134 self.has_errors.set(true);
2135 self.set_tainted_by_errors();
2139 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2140 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2143 pub fn write_method_call(&self,
2145 method: MethodCallee<'tcx>) {
2146 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2149 .type_dependent_defs_mut()
2150 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2152 self.write_substs(hir_id, method.substs);
2154 // When the method is confirmed, the `method.substs` includes
2155 // parameters from not just the method, but also the impl of
2156 // the method -- in particular, the `Self` type will be fully
2157 // resolved. However, those are not something that the "user
2158 // specified" -- i.e., those types come from the inferred type
2159 // of the receiver, not something the user wrote. So when we
2160 // create the user-substs, we want to replace those earlier
2161 // types with just the types that the user actually wrote --
2162 // that is, those that appear on the *method itself*.
2164 // As an example, if the user wrote something like
2165 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2166 // type of `foo` (possibly adjusted), but we don't want to
2167 // include that. We want just the `[_, u32]` part.
2168 if !method.substs.is_noop() {
2169 let method_generics = self.tcx.generics_of(method.def_id);
2170 if !method_generics.params.is_empty() {
2171 let user_type_annotation = self.infcx.probe(|_| {
2172 let user_substs = UserSubsts {
2173 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2174 let i = param.index as usize;
2175 if i < method_generics.parent_count {
2176 self.infcx.var_for_def(DUMMY_SP, param)
2181 user_self_ty: None, // not relevant here
2184 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2190 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2191 self.write_user_type_annotation(hir_id, user_type_annotation);
2196 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2197 if !substs.is_noop() {
2198 debug!("write_substs({:?}, {:?}) in fcx {}",
2203 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2207 /// Given the substs that we just converted from the HIR, try to
2208 /// canonicalize them and store them as user-given substitutions
2209 /// (i.e., substitutions that must be respected by the NLL check).
2211 /// This should be invoked **before any unifications have
2212 /// occurred**, so that annotations like `Vec<_>` are preserved
2214 pub fn write_user_type_annotation_from_substs(
2218 substs: SubstsRef<'tcx>,
2219 user_self_ty: Option<UserSelfTy<'tcx>>,
2222 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2223 user_self_ty={:?} in fcx {}",
2224 hir_id, def_id, substs, user_self_ty, self.tag(),
2227 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2228 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2229 &UserType::TypeOf(def_id, UserSubsts {
2234 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2235 self.write_user_type_annotation(hir_id, canonicalized);
2239 pub fn write_user_type_annotation(
2242 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2245 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2246 hir_id, canonical_user_type_annotation, self.tag(),
2249 if !canonical_user_type_annotation.is_identity() {
2250 self.tables.borrow_mut().user_provided_types_mut().insert(
2251 hir_id, canonical_user_type_annotation
2254 debug!("write_user_type_annotation: skipping identity substs");
2258 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2259 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2265 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2266 Entry::Vacant(entry) => { entry.insert(adj); },
2267 Entry::Occupied(mut entry) => {
2268 debug!(" - composing on top of {:?}", entry.get());
2269 match (&entry.get()[..], &adj[..]) {
2270 // Applying any adjustment on top of a NeverToAny
2271 // is a valid NeverToAny adjustment, because it can't
2273 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2275 Adjustment { kind: Adjust::Deref(_), .. },
2276 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2278 Adjustment { kind: Adjust::Deref(_), .. },
2279 .. // Any following adjustments are allowed.
2281 // A reborrow has no effect before a dereference.
2283 // FIXME: currently we never try to compose autoderefs
2284 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2286 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2287 expr, entry.get(), adj)
2289 *entry.get_mut() = adj;
2294 /// Basically whenever we are converting from a type scheme into
2295 /// the fn body space, we always want to normalize associated
2296 /// types as well. This function combines the two.
2297 fn instantiate_type_scheme<T>(&self,
2299 substs: SubstsRef<'tcx>,
2302 where T : TypeFoldable<'tcx>
2304 let value = value.subst(self.tcx, substs);
2305 let result = self.normalize_associated_types_in(span, &value);
2306 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2313 /// As `instantiate_type_scheme`, but for the bounds found in a
2314 /// generic type scheme.
2315 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2316 -> ty::InstantiatedPredicates<'tcx> {
2317 let bounds = self.tcx.predicates_of(def_id);
2318 let result = bounds.instantiate(self.tcx, substs);
2319 let result = self.normalize_associated_types_in(span, &result);
2320 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2327 /// Replaces the opaque types from the given value with type variables,
2328 /// and records the `OpaqueTypeMap` for later use during writeback. See
2329 /// `InferCtxt::instantiate_opaque_types` for more details.
2330 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2332 parent_id: hir::HirId,
2335 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2336 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2340 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2341 self.instantiate_opaque_types(
2349 let mut opaque_types = self.opaque_types.borrow_mut();
2350 for (ty, decl) in opaque_type_map {
2351 let old_value = opaque_types.insert(ty, decl);
2352 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2358 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2359 where T : TypeFoldable<'tcx>
2361 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2364 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2366 where T : TypeFoldable<'tcx>
2368 self.inh.partially_normalize_associated_types_in(span,
2374 pub fn require_type_meets(&self,
2377 code: traits::ObligationCauseCode<'tcx>,
2380 self.register_bound(
2383 traits::ObligationCause::new(span, self.body_id, code));
2386 pub fn require_type_is_sized(&self,
2389 code: traits::ObligationCauseCode<'tcx>)
2391 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2392 self.require_type_meets(ty, span, code, lang_item);
2395 pub fn require_type_is_sized_deferred(&self,
2398 code: traits::ObligationCauseCode<'tcx>)
2400 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2403 pub fn register_bound(&self,
2406 cause: traits::ObligationCause<'tcx>)
2408 self.fulfillment_cx.borrow_mut()
2409 .register_bound(self, self.param_env, ty, def_id, cause);
2412 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2413 let t = AstConv::ast_ty_to_ty(self, ast_t);
2414 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2418 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2419 let ty = self.to_ty(ast_ty);
2420 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2422 if Self::can_contain_user_lifetime_bounds(ty) {
2423 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2424 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2425 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2431 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2432 AstConv::ast_const_to_const(self, ast_c, ty)
2435 // If the type given by the user has free regions, save it for later, since
2436 // NLL would like to enforce those. Also pass in types that involve
2437 // projections, since those can resolve to `'static` bounds (modulo #54940,
2438 // which hopefully will be fixed by the time you see this comment, dear
2439 // reader, although I have my doubts). Also pass in types with inference
2440 // types, because they may be repeated. Other sorts of things are already
2441 // sufficiently enforced with erased regions. =)
2442 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2444 T: TypeFoldable<'tcx>
2446 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2449 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2450 match self.tables.borrow().node_types().get(id) {
2452 None if self.is_tainted_by_errors() => self.tcx.types.err,
2454 let node_id = self.tcx.hir().hir_to_node_id(id);
2455 bug!("no type for node {}: {} in fcx {}",
2456 node_id, self.tcx.hir().node_to_string(node_id),
2462 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2463 /// outlive the region `r`.
2464 pub fn register_wf_obligation(&self,
2467 code: traits::ObligationCauseCode<'tcx>)
2469 // WF obligations never themselves fail, so no real need to give a detailed cause:
2470 let cause = traits::ObligationCause::new(span, self.body_id, code);
2471 self.register_predicate(traits::Obligation::new(cause,
2473 ty::Predicate::WellFormed(ty)));
2476 /// Registers obligations that all types appearing in `substs` are well-formed.
2477 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2478 for ty in substs.types() {
2479 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2483 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2484 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2485 /// trait/region obligations.
2487 /// For example, if there is a function:
2490 /// fn foo<'a,T:'a>(...)
2493 /// and a reference:
2499 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2500 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2501 pub fn add_obligations_for_parameters(&self,
2502 cause: traits::ObligationCause<'tcx>,
2503 predicates: &ty::InstantiatedPredicates<'tcx>)
2505 assert!(!predicates.has_escaping_bound_vars());
2507 debug!("add_obligations_for_parameters(predicates={:?})",
2510 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2511 self.register_predicate(obligation);
2515 // FIXME(arielb1): use this instead of field.ty everywhere
2516 // Only for fields! Returns <none> for methods>
2517 // Indifferent to privacy flags
2518 pub fn field_ty(&self,
2520 field: &'tcx ty::FieldDef,
2521 substs: SubstsRef<'tcx>)
2524 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2527 fn check_casts(&self) {
2528 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2529 for cast in deferred_cast_checks.drain(..) {
2534 fn resolve_generator_interiors(&self, def_id: DefId) {
2535 let mut generators = self.deferred_generator_interiors.borrow_mut();
2536 for (body_id, interior) in generators.drain(..) {
2537 self.select_obligations_where_possible(false);
2538 generator_interior::resolve_interior(self, def_id, body_id, interior);
2542 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2543 // Non-numerics get replaced with ! or () (depending on whether
2544 // feature(never_type) is enabled, unconstrained ints with i32,
2545 // unconstrained floats with f64.
2546 // Fallback becomes very dubious if we have encountered type-checking errors.
2547 // In that case, fallback to Error.
2548 // The return value indicates whether fallback has occurred.
2549 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2550 use rustc::ty::error::UnconstrainedNumeric::Neither;
2551 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2553 assert!(ty.is_ty_infer());
2554 let fallback = match self.type_is_unconstrained_numeric(ty) {
2555 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2556 UnconstrainedInt => self.tcx.types.i32,
2557 UnconstrainedFloat => self.tcx.types.f64,
2558 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2559 Neither => return false,
2561 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2562 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2566 fn select_all_obligations_or_error(&self) {
2567 debug!("select_all_obligations_or_error");
2568 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2569 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2573 /// Select as many obligations as we can at present.
2574 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2575 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2576 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2580 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2581 /// returns a type of `&T`, but the actual type we assign to the
2582 /// *expression* is `T`. So this function just peels off the return
2583 /// type by one layer to yield `T`.
2584 fn make_overloaded_place_return_type(&self,
2585 method: MethodCallee<'tcx>)
2586 -> ty::TypeAndMut<'tcx>
2588 // extract method return type, which will be &T;
2589 let ret_ty = method.sig.output();
2591 // method returns &T, but the type as visible to user is T, so deref
2592 ret_ty.builtin_deref(true).unwrap()
2595 fn lookup_indexing(&self,
2597 base_expr: &'gcx hir::Expr,
2601 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2603 // FIXME(#18741) -- this is almost but not quite the same as the
2604 // autoderef that normal method probing does. They could likely be
2607 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2608 let mut result = None;
2609 while result.is_none() && autoderef.next().is_some() {
2610 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2612 autoderef.finalize(self);
2616 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2617 /// (and otherwise adjust) `base_expr`, looking for a type which either
2618 /// supports builtin indexing or overloaded indexing.
2619 /// This loop implements one step in that search; the autoderef loop
2620 /// is implemented by `lookup_indexing`.
2621 fn try_index_step(&self,
2623 base_expr: &hir::Expr,
2624 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2627 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2629 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2630 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2637 for &unsize in &[false, true] {
2638 let mut self_ty = adjusted_ty;
2640 // We only unsize arrays here.
2641 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2642 self_ty = self.tcx.mk_slice(element_ty);
2648 // If some lookup succeeds, write callee into table and extract index/element
2649 // type from the method signature.
2650 // If some lookup succeeded, install method in table
2651 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2652 let method = self.try_overloaded_place_op(
2653 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2655 let result = method.map(|ok| {
2656 debug!("try_index_step: success, using overloaded indexing");
2657 let method = self.register_infer_ok_obligations(ok);
2659 let mut adjustments = autoderef.adjust_steps(self, needs);
2660 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2661 let mutbl = match r_mutbl {
2662 hir::MutImmutable => AutoBorrowMutability::Immutable,
2663 hir::MutMutable => AutoBorrowMutability::Mutable {
2664 // Indexing can be desugared to a method call,
2665 // so maybe we could use two-phase here.
2666 // See the documentation of AllowTwoPhase for why that's
2667 // not the case today.
2668 allow_two_phase_borrow: AllowTwoPhase::No,
2671 adjustments.push(Adjustment {
2672 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2673 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2680 adjustments.push(Adjustment {
2681 kind: Adjust::Pointer(PointerCast::Unsize),
2682 target: method.sig.inputs()[0]
2685 self.apply_adjustments(base_expr, adjustments);
2687 self.write_method_call(expr.hir_id, method);
2688 (input_ty, self.make_overloaded_place_return_type(method).ty)
2690 if result.is_some() {
2698 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2699 let (tr, name) = match (op, is_mut) {
2700 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2701 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2702 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2703 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2705 (tr, ast::Ident::with_empty_ctxt(name))
2708 fn try_overloaded_place_op(&self,
2711 arg_tys: &[Ty<'tcx>],
2714 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2716 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2722 // Try Mut first, if needed.
2723 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2724 let method = match (needs, mut_tr) {
2725 (Needs::MutPlace, Some(trait_did)) => {
2726 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2731 // Otherwise, fall back to the immutable version.
2732 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2733 let method = match (method, imm_tr) {
2734 (None, Some(trait_did)) => {
2735 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2737 (method, _) => method,
2743 fn check_method_argument_types(&self,
2746 method: Result<MethodCallee<'tcx>, ()>,
2747 args_no_rcvr: &'gcx [hir::Expr],
2748 tuple_arguments: TupleArgumentsFlag,
2749 expected: Expectation<'tcx>)
2751 let has_error = match method {
2753 method.substs.references_error() || method.sig.references_error()
2758 let err_inputs = self.err_args(args_no_rcvr.len());
2760 let err_inputs = match tuple_arguments {
2761 DontTupleArguments => err_inputs,
2762 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2765 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2766 false, tuple_arguments, None);
2767 return self.tcx.types.err;
2770 let method = method.unwrap();
2771 // HACK(eddyb) ignore self in the definition (see above).
2772 let expected_arg_tys = self.expected_inputs_for_expected_output(
2775 method.sig.output(),
2776 &method.sig.inputs()[1..]
2778 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2779 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2780 self.tcx.hir().span_if_local(method.def_id));
2784 fn self_type_matches_expected_vid(
2786 trait_ref: ty::PolyTraitRef<'tcx>,
2787 expected_vid: ty::TyVid,
2789 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2791 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2792 trait_ref, self_ty, expected_vid
2795 ty::Infer(ty::TyVar(found_vid)) => {
2796 // FIXME: consider using `sub_root_var` here so we
2797 // can see through subtyping.
2798 let found_vid = self.root_var(found_vid);
2799 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2800 expected_vid == found_vid
2806 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2807 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2808 + Captures<'gcx> + 'b
2810 // FIXME: consider using `sub_root_var` here so we
2811 // can see through subtyping.
2812 let ty_var_root = self.root_var(self_ty);
2813 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2814 self_ty, ty_var_root,
2815 self.fulfillment_cx.borrow().pending_obligations());
2819 .pending_obligations()
2821 .filter_map(move |obligation| match obligation.predicate {
2822 ty::Predicate::Projection(ref data) =>
2823 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2824 ty::Predicate::Trait(ref data) =>
2825 Some((data.to_poly_trait_ref(), obligation)),
2826 ty::Predicate::Subtype(..) => None,
2827 ty::Predicate::RegionOutlives(..) => None,
2828 ty::Predicate::TypeOutlives(..) => None,
2829 ty::Predicate::WellFormed(..) => None,
2830 ty::Predicate::ObjectSafe(..) => None,
2831 ty::Predicate::ConstEvaluatable(..) => None,
2832 // N.B., this predicate is created by breaking down a
2833 // `ClosureType: FnFoo()` predicate, where
2834 // `ClosureType` represents some `Closure`. It can't
2835 // possibly be referring to the current closure,
2836 // because we haven't produced the `Closure` for
2837 // this closure yet; this is exactly why the other
2838 // code is looking for a self type of a unresolved
2839 // inference variable.
2840 ty::Predicate::ClosureKind(..) => None,
2841 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2844 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2845 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2846 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2850 /// Generic function that factors out common logic from function calls,
2851 /// method calls and overloaded operators.
2852 fn check_argument_types(&self,
2855 fn_inputs: &[Ty<'tcx>],
2856 expected_arg_tys: &[Ty<'tcx>],
2857 args: &'gcx [hir::Expr],
2859 tuple_arguments: TupleArgumentsFlag,
2860 def_span: Option<Span>) {
2863 // Grab the argument types, supplying fresh type variables
2864 // if the wrong number of arguments were supplied
2865 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2871 // All the input types from the fn signature must outlive the call
2872 // so as to validate implied bounds.
2873 for &fn_input_ty in fn_inputs {
2874 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2877 let expected_arg_count = fn_inputs.len();
2879 let param_count_error = |expected_count: usize,
2884 let mut err = tcx.sess.struct_span_err_with_code(sp,
2885 &format!("this function takes {}{} but {} {} supplied",
2886 if c_variadic { "at least " } else { "" },
2887 potentially_plural_count(expected_count, "parameter"),
2888 potentially_plural_count(arg_count, "parameter"),
2889 if arg_count == 1 {"was"} else {"were"}),
2890 DiagnosticId::Error(error_code.to_owned()));
2892 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2893 err.span_label(def_s, "defined here");
2896 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2897 // remove closing `)` from the span
2898 let sugg_span = sugg_span.shrink_to_lo();
2899 err.span_suggestion(
2901 "expected the unit value `()`; create it with empty parentheses",
2903 Applicability::MachineApplicable);
2905 err.span_label(sp, format!("expected {}{}",
2906 if c_variadic { "at least " } else { "" },
2907 potentially_plural_count(expected_count, "parameter")));
2912 let mut expected_arg_tys = expected_arg_tys.to_vec();
2914 let formal_tys = if tuple_arguments == TupleArguments {
2915 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2916 match tuple_type.sty {
2917 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2918 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2919 expected_arg_tys = vec![];
2920 self.err_args(args.len())
2922 ty::Tuple(arg_types) => {
2923 expected_arg_tys = match expected_arg_tys.get(0) {
2924 Some(&ty) => match ty.sty {
2925 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
2930 arg_types.iter().map(|k| k.expect_ty()).collect()
2933 span_err!(tcx.sess, sp, E0059,
2934 "cannot use call notation; the first type parameter \
2935 for the function trait is neither a tuple nor unit");
2936 expected_arg_tys = vec![];
2937 self.err_args(args.len())
2940 } else if expected_arg_count == supplied_arg_count {
2942 } else if c_variadic {
2943 if supplied_arg_count >= expected_arg_count {
2946 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2947 expected_arg_tys = vec![];
2948 self.err_args(supplied_arg_count)
2951 // is the missing argument of type `()`?
2952 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2953 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
2954 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2955 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
2959 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2961 expected_arg_tys = vec![];
2962 self.err_args(supplied_arg_count)
2965 debug!("check_argument_types: formal_tys={:?}",
2966 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2968 // If there is no expectation, expect formal_tys.
2969 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2975 // Check the arguments.
2976 // We do this in a pretty awful way: first we type-check any arguments
2977 // that are not closures, then we type-check the closures. This is so
2978 // that we have more information about the types of arguments when we
2979 // type-check the functions. This isn't really the right way to do this.
2980 for &check_closures in &[false, true] {
2981 debug!("check_closures={}", check_closures);
2983 // More awful hacks: before we check argument types, try to do
2984 // an "opportunistic" vtable resolution of any trait bounds on
2985 // the call. This helps coercions.
2987 self.select_obligations_where_possible(false);
2990 // For C-variadic functions, we don't have a declared type for all of
2991 // the arguments hence we only do our usual type checking with
2992 // the arguments who's types we do know.
2993 let t = if c_variadic {
2995 } else if tuple_arguments == TupleArguments {
3000 for (i, arg) in args.iter().take(t).enumerate() {
3001 // Warn only for the first loop (the "no closures" one).
3002 // Closure arguments themselves can't be diverging, but
3003 // a previous argument can, e.g., `foo(panic!(), || {})`.
3004 if !check_closures {
3005 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3008 let is_closure = match arg.node {
3009 ExprKind::Closure(..) => true,
3013 if is_closure != check_closures {
3017 debug!("checking the argument");
3018 let formal_ty = formal_tys[i];
3020 // The special-cased logic below has three functions:
3021 // 1. Provide as good of an expected type as possible.
3022 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3024 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3026 // 2. Coerce to the most detailed type that could be coerced
3027 // to, which is `expected_ty` if `rvalue_hint` returns an
3028 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3029 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3030 // We're processing function arguments so we definitely want to use
3031 // two-phase borrows.
3032 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3034 // 3. Relate the expected type and the formal one,
3035 // if the expected type was used for the coercion.
3036 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3040 // We also need to make sure we at least write the ty of the other
3041 // arguments which we skipped above.
3043 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3044 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3045 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3048 for arg in args.iter().skip(expected_arg_count) {
3049 let arg_ty = self.check_expr(&arg);
3051 // There are a few types which get autopromoted when passed via varargs
3052 // in C but we just error out instead and require explicit casts.
3053 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3055 ty::Float(ast::FloatTy::F32) => {
3056 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3058 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3059 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3061 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3062 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3065 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3066 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3067 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3075 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3076 vec![self.tcx.types.err; len]
3079 // AST fragment checking
3082 expected: Expectation<'tcx>)
3088 ast::LitKind::Str(..) => tcx.mk_static_str(),
3089 ast::LitKind::ByteStr(ref v) => {
3090 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3091 tcx.mk_array(tcx.types.u8, v.len() as u64))
3093 ast::LitKind::Byte(_) => tcx.types.u8,
3094 ast::LitKind::Char(_) => tcx.types.char,
3095 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3096 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3097 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3098 let opt_ty = expected.to_option(self).and_then(|ty| {
3100 ty::Int(_) | ty::Uint(_) => Some(ty),
3101 ty::Char => Some(tcx.types.u8),
3102 ty::RawPtr(..) => Some(tcx.types.usize),
3103 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3107 opt_ty.unwrap_or_else(|| self.next_int_var())
3109 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3110 ast::LitKind::FloatUnsuffixed(_) => {
3111 let opt_ty = expected.to_option(self).and_then(|ty| {
3113 ty::Float(_) => Some(ty),
3117 opt_ty.unwrap_or_else(|| self.next_float_var())
3119 ast::LitKind::Bool(_) => tcx.types.bool,
3120 ast::LitKind::Err(_) => tcx.types.err,
3124 fn check_expr_eq_type(&self,
3125 expr: &'gcx hir::Expr,
3126 expected: Ty<'tcx>) {
3127 let ty = self.check_expr_with_hint(expr, expected);
3128 self.demand_eqtype(expr.span, expected, ty);
3131 pub fn check_expr_has_type_or_error(&self,
3132 expr: &'gcx hir::Expr,
3133 expected: Ty<'tcx>) -> Ty<'tcx> {
3134 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3137 fn check_expr_meets_expectation_or_error(&self,
3138 expr: &'gcx hir::Expr,
3139 expected: Expectation<'tcx>) -> Ty<'tcx> {
3140 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3141 let mut ty = self.check_expr_with_expectation(expr, expected);
3143 // While we don't allow *arbitrary* coercions here, we *do* allow
3144 // coercions from ! to `expected`.
3146 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3147 "expression with never type wound up being adjusted");
3148 let adj_ty = self.next_diverging_ty_var(
3149 TypeVariableOrigin::AdjustmentType(expr.span));
3150 self.apply_adjustments(expr, vec![Adjustment {
3151 kind: Adjust::NeverToAny,
3157 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3158 let expr = match &expr.node {
3159 ExprKind::DropTemps(expr) => expr,
3162 // Error possibly reported in `check_assign` so avoid emitting error again.
3163 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3168 fn check_expr_coercable_to_type(&self,
3169 expr: &'gcx hir::Expr,
3170 expected: Ty<'tcx>) -> Ty<'tcx> {
3171 let ty = self.check_expr_with_hint(expr, expected);
3172 // checks don't need two phase
3173 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3176 fn check_expr_with_hint(&self,
3177 expr: &'gcx hir::Expr,
3178 expected: Ty<'tcx>) -> Ty<'tcx> {
3179 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3182 fn check_expr_with_expectation(&self,
3183 expr: &'gcx hir::Expr,
3184 expected: Expectation<'tcx>) -> Ty<'tcx> {
3185 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3188 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3189 self.check_expr_with_expectation(expr, NoExpectation)
3192 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3193 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3196 // Determine the `Self` type, using fresh variables for all variables
3197 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3198 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3200 pub fn impl_self_ty(&self,
3201 span: Span, // (potential) receiver for this impl
3203 -> TypeAndSubsts<'tcx> {
3204 let ity = self.tcx.type_of(did);
3205 debug!("impl_self_ty: ity={:?}", ity);
3207 let substs = self.fresh_substs_for_item(span, did);
3208 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3210 TypeAndSubsts { substs: substs, ty: substd_ty }
3213 /// Unifies the output type with the expected type early, for more coercions
3214 /// and forward type information on the input expressions.
3215 fn expected_inputs_for_expected_output(&self,
3217 expected_ret: Expectation<'tcx>,
3218 formal_ret: Ty<'tcx>,
3219 formal_args: &[Ty<'tcx>])
3221 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3222 let ret_ty = match expected_ret.only_has_type(self) {
3224 None => return Vec::new()
3226 let expect_args = self.fudge_inference_if_ok(|| {
3227 // Attempt to apply a subtyping relationship between the formal
3228 // return type (likely containing type variables if the function
3229 // is polymorphic) and the expected return type.
3230 // No argument expectations are produced if unification fails.
3231 let origin = self.misc(call_span);
3232 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3234 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3235 // to identity so the resulting type is not constrained.
3238 // Process any obligations locally as much as
3239 // we can. We don't care if some things turn
3240 // out unconstrained or ambiguous, as we're
3241 // just trying to get hints here.
3242 self.save_and_restore_in_snapshot_flag(|_| {
3243 let mut fulfill = TraitEngine::new(self.tcx);
3244 for obligation in ok.obligations {
3245 fulfill.register_predicate_obligation(self, obligation);
3247 fulfill.select_where_possible(self)
3248 }).map_err(|_| ())?;
3250 Err(_) => return Err(()),
3253 // Record all the argument types, with the substitutions
3254 // produced from the above subtyping unification.
3255 Ok(formal_args.iter().map(|ty| {
3256 self.resolve_vars_if_possible(ty)
3258 }).unwrap_or_default();
3259 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3260 formal_args, formal_ret,
3261 expect_args, expected_ret);
3265 // Checks a method call.
3266 fn check_method_call(&self,
3267 expr: &'gcx hir::Expr,
3268 segment: &hir::PathSegment,
3270 args: &'gcx [hir::Expr],
3271 expected: Expectation<'tcx>,
3272 needs: Needs) -> Ty<'tcx> {
3273 let rcvr = &args[0];
3274 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3275 // no need to check for bot/err -- callee does that
3276 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3278 let method = match self.lookup_method(rcvr_t,
3284 self.write_method_call(expr.hir_id, method);
3288 if segment.ident.name != kw::Invalid {
3289 self.report_method_error(span,
3292 SelfSource::MethodCall(rcvr),
3300 // Call the generic checker.
3301 self.check_method_argument_types(span,
3309 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3313 .unwrap_or_else(|| span_bug!(return_expr.span,
3314 "check_return_expr called outside fn body"));
3316 let ret_ty = ret_coercion.borrow().expected_ty();
3317 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3318 ret_coercion.borrow_mut()
3320 &self.cause(return_expr.span,
3321 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3326 // Check field access expressions
3327 fn check_field(&self,
3328 expr: &'gcx hir::Expr,
3330 base: &'gcx hir::Expr,
3331 field: ast::Ident) -> Ty<'tcx> {
3332 let expr_t = self.check_expr_with_needs(base, needs);
3333 let expr_t = self.structurally_resolved_type(base.span,
3335 let mut private_candidate = None;
3336 let mut autoderef = self.autoderef(expr.span, expr_t);
3337 while let Some((base_t, _)) = autoderef.next() {
3339 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3340 debug!("struct named {:?}", base_t);
3341 let (ident, def_scope) =
3342 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3343 let fields = &base_def.non_enum_variant().fields;
3344 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3345 let field = &fields[index];
3346 let field_ty = self.field_ty(expr.span, field, substs);
3347 // Save the index of all fields regardless of their visibility in case
3348 // of error recovery.
3349 self.write_field_index(expr.hir_id, index);
3350 if field.vis.is_accessible_from(def_scope, self.tcx) {
3351 let adjustments = autoderef.adjust_steps(self, needs);
3352 self.apply_adjustments(base, adjustments);
3353 autoderef.finalize(self);
3355 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3358 private_candidate = Some((base_def.did, field_ty));
3361 ty::Tuple(ref tys) => {
3362 let fstr = field.as_str();
3363 if let Ok(index) = fstr.parse::<usize>() {
3364 if fstr == index.to_string() {
3365 if let Some(field_ty) = tys.get(index) {
3366 let adjustments = autoderef.adjust_steps(self, needs);
3367 self.apply_adjustments(base, adjustments);
3368 autoderef.finalize(self);
3370 self.write_field_index(expr.hir_id, index);
3371 return field_ty.expect_ty();
3379 autoderef.unambiguous_final_ty(self);
3381 if let Some((did, field_ty)) = private_candidate {
3382 let struct_path = self.tcx().def_path_str(did);
3383 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3384 "field `{}` of struct `{}` is private",
3385 field, struct_path);
3386 // Also check if an accessible method exists, which is often what is meant.
3387 if self.method_exists(field, expr_t, expr.hir_id, false)
3388 && !self.expr_in_place(expr.hir_id)
3390 self.suggest_method_call(
3392 &format!("a method `{}` also exists, call it with parentheses", field),
3400 } else if field.name == kw::Invalid {
3401 self.tcx().types.err
3402 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3403 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3404 "attempted to take value of method `{}` on type `{}`",
3407 if !self.expr_in_place(expr.hir_id) {
3408 self.suggest_method_call(
3410 "use parentheses to call the method",
3416 err.help("methods are immutable and cannot be assigned to");
3420 self.tcx().types.err
3422 if !expr_t.is_primitive_ty() {
3423 let mut err = self.no_such_field_err(field.span, field, expr_t);
3426 ty::Adt(def, _) if !def.is_enum() => {
3427 if let Some(suggested_field_name) =
3428 Self::suggest_field_name(def.non_enum_variant(),
3429 &field.as_str(), vec![]) {
3430 err.span_suggestion(
3432 "a field with a similar name exists",
3433 suggested_field_name.to_string(),
3434 Applicability::MaybeIncorrect,
3437 err.span_label(field.span, "unknown field");
3438 let struct_variant_def = def.non_enum_variant();
3439 let field_names = self.available_field_names(struct_variant_def);
3440 if !field_names.is_empty() {
3441 err.note(&format!("available fields are: {}",
3442 self.name_series_display(field_names)));
3446 ty::Array(_, len) => {
3447 if let (Some(len), Ok(user_index)) = (
3448 len.assert_usize(self.tcx),
3449 field.as_str().parse::<u64>()
3451 let base = self.tcx.sess.source_map()
3452 .span_to_snippet(base.span)
3454 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3455 let help = "instead of using tuple indexing, use array indexing";
3456 let suggestion = format!("{}[{}]", base, field);
3457 let applicability = if len < user_index {
3458 Applicability::MachineApplicable
3460 Applicability::MaybeIncorrect
3462 err.span_suggestion(
3463 expr.span, help, suggestion, applicability
3468 let base = self.tcx.sess.source_map()
3469 .span_to_snippet(base.span)
3470 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3471 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3472 let suggestion = format!("(*{}).{}", base, field);
3473 err.span_suggestion(
3477 Applicability::MaybeIncorrect,
3484 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3485 "`{}` is a primitive type and therefore doesn't have fields",
3488 self.tcx().types.err
3492 // Return an hint about the closest match in field names
3493 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3495 skip: Vec<LocalInternedString>)
3497 let names = variant.fields.iter().filter_map(|field| {
3498 // ignore already set fields and private fields from non-local crates
3499 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3500 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3504 Some(&field.ident.name)
3508 find_best_match_for_name(names, field, None)
3511 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3512 variant.fields.iter().filter(|field| {
3513 let def_scope = self.tcx.adjust_ident(field.ident, variant.def_id, self.body_id).1;
3514 field.vis.is_accessible_from(def_scope, self.tcx)
3516 .map(|field| field.ident.name)
3520 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3521 // dynamic limit, to never omit just one field
3522 let limit = if names.len() == 6 { 6 } else { 5 };
3523 let mut display = names.iter().take(limit)
3524 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3525 if names.len() > limit {
3526 display = format!("{} ... and {} others", display, names.len() - limit);
3531 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3532 -> DiagnosticBuilder<'_> {
3533 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3534 "no field `{}` on type `{}`",
3538 fn report_unknown_field(
3541 variant: &'tcx ty::VariantDef,
3543 skip_fields: &[hir::Field],
3546 if variant.recovered {
3549 let mut err = self.type_error_struct_with_diag(
3551 |actual| match ty.sty {
3552 ty::Adt(adt, ..) if adt.is_enum() => {
3553 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3554 "{} `{}::{}` has no field named `{}`",
3555 kind_name, actual, variant.ident, field.ident)
3558 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3559 "{} `{}` has no field named `{}`",
3560 kind_name, actual, field.ident)
3564 // prevent all specified fields from being suggested
3565 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3566 if let Some(field_name) = Self::suggest_field_name(variant,
3567 &field.ident.as_str(),
3568 skip_fields.collect()) {
3569 err.span_suggestion(
3571 "a field with a similar name exists",
3572 field_name.to_string(),
3573 Applicability::MaybeIncorrect,
3577 ty::Adt(adt, ..) => {
3579 err.span_label(field.ident.span,
3580 format!("`{}::{}` does not have this field",
3581 ty, variant.ident));
3583 err.span_label(field.ident.span,
3584 format!("`{}` does not have this field", ty));
3586 let available_field_names = self.available_field_names(variant);
3587 if !available_field_names.is_empty() {
3588 err.note(&format!("available fields are: {}",
3589 self.name_series_display(available_field_names)));
3592 _ => bug!("non-ADT passed to report_unknown_field")
3598 fn check_expr_struct_fields(&self,
3600 expected: Expectation<'tcx>,
3601 expr_id: hir::HirId,
3603 variant: &'tcx ty::VariantDef,
3604 ast_fields: &'gcx [hir::Field],
3605 check_completeness: bool) -> bool {
3609 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3610 .get(0).cloned().unwrap_or(adt_ty);
3611 // re-link the regions that EIfEO can erase.
3612 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3614 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3615 &ty::Adt(adt, substs) => {
3616 (substs, adt.adt_kind(), adt.variant_descr())
3618 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3621 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3622 (field.ident.modern(), (i, field))
3623 ).collect::<FxHashMap<_, _>>();
3625 let mut seen_fields = FxHashMap::default();
3627 let mut error_happened = false;
3629 // Type-check each field.
3630 for field in ast_fields {
3631 let ident = tcx.adjust_ident(field.ident, variant.def_id, self.body_id).0;
3632 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3633 seen_fields.insert(ident, field.span);
3634 self.write_field_index(field.hir_id, i);
3636 // We don't look at stability attributes on
3637 // struct-like enums (yet...), but it's definitely not
3638 // a bug to have constructed one.
3639 if adt_kind != AdtKind::Enum {
3640 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3643 self.field_ty(field.span, v_field, substs)
3645 error_happened = true;
3646 if let Some(prev_span) = seen_fields.get(&ident) {
3647 let mut err = struct_span_err!(self.tcx.sess,
3650 "field `{}` specified more than once",
3653 err.span_label(field.ident.span, "used more than once");
3654 err.span_label(*prev_span, format!("first use of `{}`", ident));
3658 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3664 // Make sure to give a type to the field even if there's
3665 // an error, so we can continue type-checking.
3666 self.check_expr_coercable_to_type(&field.expr, field_type);
3669 // Make sure the programmer specified correct number of fields.
3670 if kind_name == "union" {
3671 if ast_fields.len() != 1 {
3672 tcx.sess.span_err(span, "union expressions should have exactly one field");
3674 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3675 let len = remaining_fields.len();
3677 let mut displayable_field_names = remaining_fields
3679 .map(|ident| ident.as_str())
3680 .collect::<Vec<_>>();
3682 displayable_field_names.sort();
3684 let truncated_fields_error = if len <= 3 {
3687 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3690 let remaining_fields_names = displayable_field_names.iter().take(3)
3691 .map(|n| format!("`{}`", n))
3692 .collect::<Vec<_>>()
3695 struct_span_err!(tcx.sess, span, E0063,
3696 "missing field{} {}{} in initializer of `{}`",
3697 if remaining_fields.len() == 1 { "" } else { "s" },
3698 remaining_fields_names,
3699 truncated_fields_error,
3701 .span_label(span, format!("missing {}{}",
3702 remaining_fields_names,
3703 truncated_fields_error))
3709 fn check_struct_fields_on_error(&self,
3710 fields: &'gcx [hir::Field],
3711 base_expr: &'gcx Option<P<hir::Expr>>) {
3712 for field in fields {
3713 self.check_expr(&field.expr);
3715 if let Some(ref base) = *base_expr {
3716 self.check_expr(&base);
3720 pub fn check_struct_path(&self,
3723 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3724 let path_span = match *qpath {
3725 QPath::Resolved(_, ref path) => path.span,
3726 QPath::TypeRelative(ref qself, _) => qself.span
3728 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3729 let variant = match def {
3731 self.set_tainted_by_errors();
3734 Res::Def(DefKind::Variant, _) => {
3736 ty::Adt(adt, substs) => {
3737 Some((adt.variant_of_res(def), adt.did, substs))
3739 _ => bug!("unexpected type: {:?}", ty)
3742 Res::Def(DefKind::Struct, _)
3743 | Res::Def(DefKind::Union, _)
3744 | Res::Def(DefKind::TyAlias, _)
3745 | Res::Def(DefKind::AssocTy, _)
3746 | Res::SelfTy(..) => {
3748 ty::Adt(adt, substs) if !adt.is_enum() => {
3749 Some((adt.non_enum_variant(), adt.did, substs))
3754 _ => bug!("unexpected definition: {:?}", def)
3757 if let Some((variant, did, substs)) = variant {
3758 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3759 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3761 // Check bounds on type arguments used in the path.
3762 let bounds = self.instantiate_bounds(path_span, did, substs);
3763 let cause = traits::ObligationCause::new(path_span, self.body_id,
3764 traits::ItemObligation(did));
3765 self.add_obligations_for_parameters(cause, &bounds);
3769 struct_span_err!(self.tcx.sess, path_span, E0071,
3770 "expected struct, variant or union type, found {}",
3771 ty.sort_string(self.tcx))
3772 .span_label(path_span, "not a struct")
3778 fn check_expr_struct(&self,
3780 expected: Expectation<'tcx>,
3782 fields: &'gcx [hir::Field],
3783 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3785 // Find the relevant variant
3786 let (variant, adt_ty) =
3787 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3790 self.check_struct_fields_on_error(fields, base_expr);
3791 return self.tcx.types.err;
3794 let path_span = match *qpath {
3795 QPath::Resolved(_, ref path) => path.span,
3796 QPath::TypeRelative(ref qself, _) => qself.span
3799 // Prohibit struct expressions when non-exhaustive flag is set.
3800 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3801 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3802 span_err!(self.tcx.sess, expr.span, E0639,
3803 "cannot create non-exhaustive {} using struct expression",
3804 adt.variant_descr());
3807 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3808 variant, fields, base_expr.is_none());
3809 if let &Some(ref base_expr) = base_expr {
3810 // If check_expr_struct_fields hit an error, do not attempt to populate
3811 // the fields with the base_expr. This could cause us to hit errors later
3812 // when certain fields are assumed to exist that in fact do not.
3813 if !error_happened {
3814 self.check_expr_has_type_or_error(base_expr, adt_ty);
3816 ty::Adt(adt, substs) if adt.is_struct() => {
3817 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3818 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3823 .fru_field_types_mut()
3824 .insert(expr.hir_id, fru_field_types);
3827 span_err!(self.tcx.sess, base_expr.span, E0436,
3828 "functional record update syntax requires a struct");
3833 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3839 /// If an expression has any sub-expressions that result in a type error,
3840 /// inspecting that expression's type with `ty.references_error()` will return
3841 /// true. Likewise, if an expression is known to diverge, inspecting its
3842 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3843 /// strict, _|_ can appear in the type of an expression that does not,
3844 /// itself, diverge: for example, fn() -> _|_.)
3845 /// Note that inspecting a type's structure *directly* may expose the fact
3846 /// that there are actually multiple representations for `Error`, so avoid
3847 /// that when err needs to be handled differently.
3848 fn check_expr_with_expectation_and_needs(&self,
3849 expr: &'gcx hir::Expr,
3850 expected: Expectation<'tcx>,
3851 needs: Needs) -> Ty<'tcx> {
3852 debug!(">> type-checking: expr={:?} expected={:?}",
3855 // Warn for expressions after diverging siblings.
3856 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3858 // Hide the outer diverging and has_errors flags.
3859 let old_diverges = self.diverges.get();
3860 let old_has_errors = self.has_errors.get();
3861 self.diverges.set(Diverges::Maybe);
3862 self.has_errors.set(false);
3864 let ty = self.check_expr_kind(expr, expected, needs);
3866 // Warn for non-block expressions with diverging children.
3868 ExprKind::Block(..) |
3869 ExprKind::Loop(..) | ExprKind::While(..) |
3870 ExprKind::Match(..) => {}
3872 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3875 // Any expression that produces a value of type `!` must have diverged
3877 self.diverges.set(self.diverges.get() | Diverges::Always);
3880 // Record the type, which applies it effects.
3881 // We need to do this after the warning above, so that
3882 // we don't warn for the diverging expression itself.
3883 self.write_ty(expr.hir_id, ty);
3885 // Combine the diverging and has_error flags.
3886 self.diverges.set(self.diverges.get() | old_diverges);
3887 self.has_errors.set(self.has_errors.get() | old_has_errors);
3889 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3890 debug!("... {:?}, expected is {:?}", ty, expected);
3897 expr: &'gcx hir::Expr,
3898 expected: Expectation<'tcx>,
3902 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3909 let id = expr.hir_id;
3911 ExprKind::Box(ref subexpr) => {
3912 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3914 ty::Adt(def, _) if def.is_box()
3915 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3919 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3920 tcx.mk_box(referent_ty)
3923 ExprKind::Lit(ref lit) => {
3924 self.check_lit(&lit, expected)
3926 ExprKind::Binary(op, ref lhs, ref rhs) => {
3927 self.check_binop(expr, op, lhs, rhs)
3929 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3930 self.check_binop_assign(expr, op, lhs, rhs)
3932 ExprKind::Unary(unop, ref oprnd) => {
3933 let expected_inner = match unop {
3934 hir::UnNot | hir::UnNeg => {
3941 let needs = match unop {
3942 hir::UnDeref => needs,
3945 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3949 if !oprnd_t.references_error() {
3950 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3953 if let Some(mt) = oprnd_t.builtin_deref(true) {
3955 } else if let Some(ok) = self.try_overloaded_deref(
3956 expr.span, oprnd_t, needs) {
3957 let method = self.register_infer_ok_obligations(ok);
3958 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3959 let mutbl = match mutbl {
3960 hir::MutImmutable => AutoBorrowMutability::Immutable,
3961 hir::MutMutable => AutoBorrowMutability::Mutable {
3962 // (It shouldn't actually matter for unary ops whether
3963 // we enable two-phase borrows or not, since a unary
3964 // op has no additional operands.)
3965 allow_two_phase_borrow: AllowTwoPhase::No,
3968 self.apply_adjustments(oprnd, vec![Adjustment {
3969 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3970 target: method.sig.inputs()[0]
3973 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3974 self.write_method_call(expr.hir_id, method);
3976 let mut err = type_error_struct!(
3981 "type `{}` cannot be dereferenced",
3984 let sp = tcx.sess.source_map().start_point(expr.span);
3985 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
3988 tcx.sess.parse_sess.expr_parentheses_needed(
3995 oprnd_t = tcx.types.err;
3999 let result = self.check_user_unop(expr, oprnd_t, unop);
4000 // If it's builtin, we can reuse the type, this helps inference.
4001 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4006 let result = self.check_user_unop(expr, oprnd_t, unop);
4007 // If it's builtin, we can reuse the type, this helps inference.
4008 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4016 ExprKind::AddrOf(mutbl, ref oprnd) => {
4017 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4019 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4020 if oprnd.is_place_expr() {
4021 // Places may legitimately have unsized types.
4022 // For example, dereferences of a fat pointer and
4023 // the last field of a struct can be unsized.
4026 Expectation::rvalue_hint(self, ty)
4032 let needs = Needs::maybe_mut_place(mutbl);
4033 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4035 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4036 if tm.ty.references_error() {
4039 // Note: at this point, we cannot say what the best lifetime
4040 // is to use for resulting pointer. We want to use the
4041 // shortest lifetime possible so as to avoid spurious borrowck
4042 // errors. Moreover, the longest lifetime will depend on the
4043 // precise details of the value whose address is being taken
4044 // (and how long it is valid), which we don't know yet until type
4045 // inference is complete.
4047 // Therefore, here we simply generate a region variable. The
4048 // region inferencer will then select the ultimate value.
4049 // Finally, borrowck is charged with guaranteeing that the
4050 // value whose address was taken can actually be made to live
4051 // as long as it needs to live.
4052 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4053 tcx.mk_ref(region, tm)
4056 ExprKind::Path(ref qpath) => {
4057 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4059 let ty = match res {
4061 self.set_tainted_by_errors();
4064 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4065 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4068 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4071 if let ty::FnDef(..) = ty.sty {
4072 let fn_sig = ty.fn_sig(tcx);
4073 if !tcx.features().unsized_locals {
4074 // We want to remove some Sized bounds from std functions,
4075 // but don't want to expose the removal to stable Rust.
4076 // i.e., we don't want to allow
4082 // to work in stable even if the Sized bound on `drop` is relaxed.
4083 for i in 0..fn_sig.inputs().skip_binder().len() {
4084 // We just want to check sizedness, so instead of introducing
4085 // placeholder lifetimes with probing, we just replace higher lifetimes
4087 let input = self.replace_bound_vars_with_fresh_vars(
4089 infer::LateBoundRegionConversionTime::FnCall,
4090 &fn_sig.input(i)).0;
4091 self.require_type_is_sized_deferred(input, expr.span,
4092 traits::SizedArgumentType);
4095 // Here we want to prevent struct constructors from returning unsized types.
4096 // There were two cases this happened: fn pointer coercion in stable
4097 // and usual function call in presense of unsized_locals.
4098 // Also, as we just want to check sizedness, instead of introducing
4099 // placeholder lifetimes with probing, we just replace higher lifetimes
4101 let output = self.replace_bound_vars_with_fresh_vars(
4103 infer::LateBoundRegionConversionTime::FnCall,
4104 &fn_sig.output()).0;
4105 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4108 // We always require that the type provided as the value for
4109 // a type parameter outlives the moment of instantiation.
4110 let substs = self.tables.borrow().node_substs(expr.hir_id);
4111 self.add_wf_bounds(substs, expr);
4115 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4116 for expr in outputs.iter().chain(inputs.iter()) {
4117 self.check_expr(expr);
4121 ExprKind::Break(destination, ref expr_opt) => {
4122 if let Ok(target_id) = destination.target_id {
4124 if let Some(ref e) = *expr_opt {
4125 // If this is a break with a value, we need to type-check
4126 // the expression. Get an expected type from the loop context.
4127 let opt_coerce_to = {
4128 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4129 enclosing_breakables.find_breakable(target_id)
4132 .map(|coerce| coerce.expected_ty())
4135 // If the loop context is not a `loop { }`, then break with
4136 // a value is illegal, and `opt_coerce_to` will be `None`.
4137 // Just set expectation to error in that case.
4138 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4140 // Recurse without `enclosing_breakables` borrowed.
4141 e_ty = self.check_expr_with_hint(e, coerce_to);
4142 cause = self.misc(e.span);
4144 // Otherwise, this is a break *without* a value. That's
4145 // always legal, and is equivalent to `break ()`.
4146 e_ty = tcx.mk_unit();
4147 cause = self.misc(expr.span);
4150 // Now that we have type-checked `expr_opt`, borrow
4151 // the `enclosing_loops` field and let's coerce the
4152 // type of `expr_opt` into what is expected.
4153 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4154 let ctxt = enclosing_breakables.find_breakable(target_id);
4155 if let Some(ref mut coerce) = ctxt.coerce {
4156 if let Some(ref e) = *expr_opt {
4157 coerce.coerce(self, &cause, e, e_ty);
4159 assert!(e_ty.is_unit());
4160 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4163 // If `ctxt.coerce` is `None`, we can just ignore
4164 // the type of the expresison. This is because
4165 // either this was a break *without* a value, in
4166 // which case it is always a legal type (`()`), or
4167 // else an error would have been flagged by the
4168 // `loops` pass for using break with an expression
4169 // where you are not supposed to.
4170 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4173 ctxt.may_break = true;
4175 // the type of a `break` is always `!`, since it diverges
4178 // Otherwise, we failed to find the enclosing loop;
4179 // this can only happen if the `break` was not
4180 // inside a loop at all, which is caught by the
4181 // loop-checking pass.
4182 if self.tcx.sess.err_count() == 0 {
4183 self.tcx.sess.delay_span_bug(expr.span,
4184 "break was outside loop, but no error was emitted");
4187 // We still need to assign a type to the inner expression to
4188 // prevent the ICE in #43162.
4189 if let Some(ref e) = *expr_opt {
4190 self.check_expr_with_hint(e, tcx.types.err);
4192 // ... except when we try to 'break rust;'.
4193 // ICE this expression in particular (see #43162).
4194 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4195 if path.segments.len() == 1 &&
4196 path.segments[0].ident.name == sym::rust {
4197 fatally_break_rust(self.tcx.sess);
4201 // There was an error; make type-check fail.
4206 ExprKind::Continue(destination) => {
4207 if destination.target_id.is_ok() {
4210 // There was an error; make type-check fail.
4214 ExprKind::Ret(ref expr_opt) => {
4215 if self.ret_coercion.is_none() {
4216 struct_span_err!(self.tcx.sess, expr.span, E0572,
4217 "return statement outside of function body").emit();
4218 } else if let Some(ref e) = *expr_opt {
4219 if self.ret_coercion_span.borrow().is_none() {
4220 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4222 self.check_return_expr(e);
4224 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4225 if self.ret_coercion_span.borrow().is_none() {
4226 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4228 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4229 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4230 coercion.coerce_forced_unit(
4235 fn_decl.output.span(),
4237 "expected `{}` because of this return type",
4245 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4250 ExprKind::Assign(ref lhs, ref rhs) => {
4251 self.check_assign(expr, expected, lhs, rhs)
4253 ExprKind::While(ref cond, ref body, _) => {
4254 let ctxt = BreakableCtxt {
4255 // cannot use break with a value from a while loop
4257 may_break: false, // Will get updated if/when we find a `break`.
4260 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4261 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4262 let cond_diverging = self.diverges.get();
4263 self.check_block_no_value(&body);
4265 // We may never reach the body so it diverging means nothing.
4266 self.diverges.set(cond_diverging);
4270 // No way to know whether it's diverging because
4271 // of a `break` or an outer `break` or `return`.
4272 self.diverges.set(Diverges::Maybe);
4277 ExprKind::Loop(ref body, _, source) => {
4278 let coerce = match source {
4279 // you can only use break with a value from a normal `loop { }`
4280 hir::LoopSource::Loop => {
4281 let coerce_to = expected.coercion_target_type(self, body.span);
4282 Some(CoerceMany::new(coerce_to))
4285 hir::LoopSource::WhileLet |
4286 hir::LoopSource::ForLoop => {
4291 let ctxt = BreakableCtxt {
4293 may_break: false, // Will get updated if/when we find a `break`.
4296 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4297 self.check_block_no_value(&body);
4301 // No way to know whether it's diverging because
4302 // of a `break` or an outer `break` or `return`.
4303 self.diverges.set(Diverges::Maybe);
4306 // If we permit break with a value, then result type is
4307 // the LUB of the breaks (possibly ! if none); else, it
4308 // is nil. This makes sense because infinite loops
4309 // (which would have type !) are only possible iff we
4310 // permit break with a value [1].
4311 if ctxt.coerce.is_none() && !ctxt.may_break {
4313 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4315 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4317 ExprKind::Match(ref discrim, ref arms, match_src) => {
4318 self.check_match(expr, &discrim, arms, expected, match_src)
4320 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4321 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4323 ExprKind::Block(ref body, _) => {
4324 self.check_block_with_expected(&body, expected)
4326 ExprKind::Call(ref callee, ref args) => {
4327 self.check_call(expr, &callee, args, expected)
4329 ExprKind::MethodCall(ref segment, span, ref args) => {
4330 self.check_method_call(expr, segment, span, args, expected, needs)
4332 ExprKind::Cast(ref e, ref t) => {
4333 // Find the type of `e`. Supply hints based on the type we are casting to,
4335 let t_cast = self.to_ty_saving_user_provided_ty(t);
4336 let t_cast = self.resolve_vars_if_possible(&t_cast);
4337 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4338 let t_cast = self.resolve_vars_if_possible(&t_cast);
4340 // Eagerly check for some obvious errors.
4341 if t_expr.references_error() || t_cast.references_error() {
4344 // Defer other checks until we're done type checking.
4345 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4346 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4348 deferred_cast_checks.push(cast_check);
4351 Err(ErrorReported) => {
4357 ExprKind::Type(ref e, ref t) => {
4358 let ty = self.to_ty_saving_user_provided_ty(&t);
4359 self.check_expr_eq_type(&e, ty);
4362 ExprKind::DropTemps(ref e) => {
4363 self.check_expr_with_expectation(e, expected)
4365 ExprKind::Array(ref args) => {
4366 let uty = expected.to_option(self).and_then(|uty| {
4368 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4373 let element_ty = if !args.is_empty() {
4374 let coerce_to = uty.unwrap_or_else(
4375 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4376 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4377 assert_eq!(self.diverges.get(), Diverges::Maybe);
4379 let e_ty = self.check_expr_with_hint(e, coerce_to);
4380 let cause = self.misc(e.span);
4381 coerce.coerce(self, &cause, e, e_ty);
4383 coerce.complete(self)
4385 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4387 tcx.mk_array(element_ty, args.len() as u64)
4389 ExprKind::Repeat(ref element, ref count) => {
4390 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4391 let param_env = ty::ParamEnv::empty();
4392 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4393 let instance = ty::Instance::resolve(
4399 let global_id = GlobalId {
4403 let count = tcx.const_eval(param_env.and(global_id));
4405 let uty = match expected {
4406 ExpectHasType(uty) => {
4408 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4415 let (element_ty, t) = match uty {
4417 self.check_expr_coercable_to_type(&element, uty);
4421 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4422 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4427 if let Ok(count) = count {
4428 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4430 // For [foo, ..n] where n > 1, `foo` must have
4432 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4433 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4437 if element_ty.references_error() {
4439 } else if let Ok(count) = count {
4440 tcx.mk_ty(ty::Array(t, count))
4445 ExprKind::Tup(ref elts) => {
4446 let flds = expected.only_has_type(self).and_then(|ty| {
4447 let ty = self.resolve_type_vars_with_obligations(ty);
4449 ty::Tuple(ref flds) => Some(&flds[..]),
4454 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4455 let t = match flds {
4456 Some(ref fs) if i < fs.len() => {
4457 let ety = fs[i].expect_ty();
4458 self.check_expr_coercable_to_type(&e, ety);
4462 self.check_expr_with_expectation(&e, NoExpectation)
4467 let tuple = tcx.mk_tup(elt_ts_iter);
4468 if tuple.references_error() {
4471 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4475 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4476 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4478 ExprKind::Field(ref base, field) => {
4479 self.check_field(expr, needs, &base, field)
4481 ExprKind::Index(ref base, ref idx) => {
4482 let base_t = self.check_expr_with_needs(&base, needs);
4483 let idx_t = self.check_expr(&idx);
4485 if base_t.references_error() {
4487 } else if idx_t.references_error() {
4490 let base_t = self.structurally_resolved_type(base.span, base_t);
4491 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4492 Some((index_ty, element_ty)) => {
4493 // two-phase not needed because index_ty is never mutable
4494 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4499 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4500 "cannot index into a value of type `{}`",
4502 // Try to give some advice about indexing tuples.
4503 if let ty::Tuple(..) = base_t.sty {
4504 let mut needs_note = true;
4505 // If the index is an integer, we can show the actual
4506 // fixed expression:
4507 if let ExprKind::Lit(ref lit) = idx.node {
4508 if let ast::LitKind::Int(i,
4509 ast::LitIntType::Unsuffixed) = lit.node {
4510 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4511 if let Ok(snip) = snip {
4512 err.span_suggestion(
4514 "to access tuple elements, use",
4515 format!("{}.{}", snip, i),
4516 Applicability::MachineApplicable,
4523 err.help("to access tuple elements, use tuple indexing \
4524 syntax (e.g., `tuple.0`)");
4533 ExprKind::Yield(ref value) => {
4534 match self.yield_ty {
4536 self.check_expr_coercable_to_type(&value, ty);
4539 struct_span_err!(self.tcx.sess, expr.span, E0627,
4540 "yield statement outside of generator literal").emit();
4545 hir::ExprKind::Err => {
4551 /// Type check assignment expression `expr` of form `lhs = rhs`.
4552 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4555 expr: &'gcx hir::Expr,
4556 expected: Expectation<'tcx>,
4557 lhs: &'gcx hir::Expr,
4558 rhs: &'gcx hir::Expr,
4560 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4561 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4563 let expected_ty = expected.coercion_target_type(self, expr.span);
4564 if expected_ty == self.tcx.types.bool {
4565 // The expected type is `bool` but this will result in `()` so we can reasonably
4566 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4567 // The likely cause of this is `if foo = bar { .. }`.
4568 let actual_ty = self.tcx.mk_unit();
4569 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4570 let msg = "try comparing for equality";
4571 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4572 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4573 if let (Ok(left), Ok(right)) = (left, right) {
4574 let help = format!("{} == {}", left, right);
4575 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4580 } else if !lhs.is_place_expr() {
4581 struct_span_err!(self.tcx.sess, expr.span, E0070,
4582 "invalid left-hand side expression")
4583 .span_label(expr.span, "left-hand of expression not valid")
4587 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4589 if lhs_ty.references_error() || rhs_ty.references_error() {
4596 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4597 // The newly resolved definition is written into `type_dependent_defs`.
4598 fn finish_resolving_struct_path(&self,
4605 QPath::Resolved(ref maybe_qself, ref path) => {
4606 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4607 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4610 QPath::TypeRelative(ref qself, ref segment) => {
4611 let ty = self.to_ty(qself);
4613 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4618 let result = AstConv::associated_path_to_ty(
4627 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4628 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4630 // Write back the new resolution.
4631 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4633 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4638 /// Resolves associated value path into a base type and associated constant or method
4639 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4640 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4644 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4646 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4647 let (ty, qself, item_segment) = match *qpath {
4648 QPath::Resolved(ref opt_qself, ref path) => {
4650 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4651 &path.segments[..]);
4653 QPath::TypeRelative(ref qself, ref segment) => {
4654 (self.to_ty(qself), qself, segment)
4657 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4658 // Return directly on cache hit. This is useful to avoid doubly reporting
4659 // errors with default match binding modes. See #44614.
4660 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4661 .unwrap_or(Res::Err);
4662 return (def, Some(ty), slice::from_ref(&**item_segment));
4664 let item_name = item_segment.ident;
4665 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4666 let result = match error {
4667 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4668 _ => Err(ErrorReported),
4670 if item_name.name != kw::Invalid {
4671 self.report_method_error(
4675 SelfSource::QPath(qself),
4683 // Write back the new resolution.
4684 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4686 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4688 slice::from_ref(&**item_segment),
4692 pub fn check_decl_initializer(&self,
4693 local: &'gcx hir::Local,
4694 init: &'gcx hir::Expr) -> Ty<'tcx>
4696 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4697 // for #42640 (default match binding modes).
4700 let ref_bindings = local.pat.contains_explicit_ref_binding();
4702 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4703 if let Some(m) = ref_bindings {
4704 // Somewhat subtle: if we have a `ref` binding in the pattern,
4705 // we want to avoid introducing coercions for the RHS. This is
4706 // both because it helps preserve sanity and, in the case of
4707 // ref mut, for soundness (issue #23116). In particular, in
4708 // the latter case, we need to be clear that the type of the
4709 // referent for the reference that results is *equal to* the
4710 // type of the place it is referencing, and not some
4711 // supertype thereof.
4712 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4713 self.demand_eqtype(init.span, local_ty, init_ty);
4716 self.check_expr_coercable_to_type(init, local_ty)
4720 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4721 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4722 self.write_ty(local.hir_id, t);
4724 if let Some(ref init) = local.init {
4725 let init_ty = self.check_decl_initializer(local, &init);
4726 if init_ty.references_error() {
4727 self.write_ty(local.hir_id, init_ty);
4731 self.check_pat_walk(
4734 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4737 let pat_ty = self.node_ty(local.pat.hir_id);
4738 if pat_ty.references_error() {
4739 self.write_ty(local.hir_id, pat_ty);
4743 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4744 // Don't do all the complex logic below for `DeclItem`.
4746 hir::StmtKind::Item(..) => return,
4747 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4750 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4752 // Hide the outer diverging and `has_errors` flags.
4753 let old_diverges = self.diverges.get();
4754 let old_has_errors = self.has_errors.get();
4755 self.diverges.set(Diverges::Maybe);
4756 self.has_errors.set(false);
4759 hir::StmtKind::Local(ref l) => {
4760 self.check_decl_local(&l);
4763 hir::StmtKind::Item(_) => {}
4764 hir::StmtKind::Expr(ref expr) => {
4765 // Check with expected type of `()`.
4766 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4768 hir::StmtKind::Semi(ref expr) => {
4769 self.check_expr(&expr);
4773 // Combine the diverging and `has_error` flags.
4774 self.diverges.set(self.diverges.get() | old_diverges);
4775 self.has_errors.set(self.has_errors.get() | old_has_errors);
4778 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4779 let unit = self.tcx.mk_unit();
4780 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4782 // if the block produces a `!` value, that can always be
4783 // (effectively) coerced to unit.
4785 self.demand_suptype(blk.span, unit, ty);
4789 fn check_block_with_expected(&self,
4790 blk: &'gcx hir::Block,
4791 expected: Expectation<'tcx>) -> Ty<'tcx> {
4793 let mut fcx_ps = self.ps.borrow_mut();
4794 let unsafety_state = fcx_ps.recurse(blk);
4795 replace(&mut *fcx_ps, unsafety_state)
4798 // In some cases, blocks have just one exit, but other blocks
4799 // can be targeted by multiple breaks. This can happen both
4800 // with labeled blocks as well as when we desugar
4801 // a `try { ... }` expression.
4805 // 'a: { if true { break 'a Err(()); } Ok(()) }
4807 // Here we would wind up with two coercions, one from
4808 // `Err(())` and the other from the tail expression
4809 // `Ok(())`. If the tail expression is omitted, that's a
4810 // "forced unit" -- unless the block diverges, in which
4811 // case we can ignore the tail expression (e.g., `'a: {
4812 // break 'a 22; }` would not force the type of the block
4814 let tail_expr = blk.expr.as_ref();
4815 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4816 let coerce = if blk.targeted_by_break {
4817 CoerceMany::new(coerce_to_ty)
4819 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4820 Some(e) => slice::from_ref(e),
4823 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4826 let prev_diverges = self.diverges.get();
4827 let ctxt = BreakableCtxt {
4828 coerce: Some(coerce),
4832 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4833 for s in &blk.stmts {
4837 // check the tail expression **without** holding the
4838 // `enclosing_breakables` lock below.
4839 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4841 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4842 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4843 let coerce = ctxt.coerce.as_mut().unwrap();
4844 if let Some(tail_expr_ty) = tail_expr_ty {
4845 let tail_expr = tail_expr.unwrap();
4846 let cause = self.cause(tail_expr.span,
4847 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4853 // Subtle: if there is no explicit tail expression,
4854 // that is typically equivalent to a tail expression
4855 // of `()` -- except if the block diverges. In that
4856 // case, there is no value supplied from the tail
4857 // expression (assuming there are no other breaks,
4858 // this implies that the type of the block will be
4861 // #41425 -- label the implicit `()` as being the
4862 // "found type" here, rather than the "expected type".
4863 if !self.diverges.get().always() {
4864 // #50009 -- Do not point at the entire fn block span, point at the return type
4865 // span, as it is the cause of the requirement, and
4866 // `consider_hint_about_removing_semicolon` will point at the last expression
4867 // if it were a relevant part of the error. This improves usability in editors
4868 // that highlight errors inline.
4869 let mut sp = blk.span;
4870 let mut fn_span = None;
4871 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4872 let ret_sp = decl.output.span();
4873 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4874 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4875 // output would otherwise be incorrect and even misleading. Make sure
4876 // the span we're aiming at correspond to a `fn` body.
4877 if block_sp == blk.span {
4879 fn_span = Some(ident.span);
4883 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4884 if let Some(expected_ty) = expected.only_has_type(self) {
4885 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4887 if let Some(fn_span) = fn_span {
4888 err.span_label(fn_span, "this function's body doesn't return");
4896 // If we can break from the block, then the block's exit is always reachable
4897 // (... as long as the entry is reachable) - regardless of the tail of the block.
4898 self.diverges.set(prev_diverges);
4901 let mut ty = ctxt.coerce.unwrap().complete(self);
4903 if self.has_errors.get() || ty.references_error() {
4904 ty = self.tcx.types.err
4907 self.write_ty(blk.hir_id, ty);
4909 *self.ps.borrow_mut() = prev;
4913 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4914 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4916 Node::Item(&hir::Item {
4917 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4919 Node::ImplItem(&hir::ImplItem {
4920 node: hir::ImplItemKind::Method(_, body_id), ..
4922 let body = self.tcx.hir().body(body_id);
4923 if let ExprKind::Block(block, _) = &body.value.node {
4924 return Some(block.span);
4932 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4933 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4934 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4935 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4938 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4939 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4941 Node::Item(&hir::Item {
4942 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4943 }) => decl.clone().and_then(|decl| {
4944 // This is less than ideal, it will not suggest a return type span on any
4945 // method called `main`, regardless of whether it is actually the entry point,
4946 // but it will still present it as the reason for the expected type.
4947 Some((decl, ident, ident.name != sym::main))
4949 Node::TraitItem(&hir::TraitItem {
4950 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4953 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
4954 Node::ImplItem(&hir::ImplItem {
4955 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4958 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
4963 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4964 /// suggestion can be made, `None` otherwise.
4965 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
4966 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4967 // `while` before reaching it, as block tail returns are not available in them.
4968 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4969 let parent = self.tcx.hir().get_by_hir_id(blk_id);
4970 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4974 /// On implicit return expressions with mismatched types, provides the following suggestions:
4976 /// - Points out the method's return type as the reason for the expected type.
4977 /// - Possible missing semicolon.
4978 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4979 pub fn suggest_mismatched_types_on_tail(
4981 err: &mut DiagnosticBuilder<'tcx>,
4982 expression: &'gcx hir::Expr,
4988 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4989 let mut pointing_at_return_type = false;
4990 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4991 pointing_at_return_type = self.suggest_missing_return_type(
4992 err, &fn_decl, expected, found, can_suggest);
4994 self.suggest_ref_or_into(err, expression, expected, found);
4995 pointing_at_return_type
4998 pub fn suggest_ref_or_into(
5000 err: &mut DiagnosticBuilder<'tcx>,
5005 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5006 err.span_suggestion(
5010 Applicability::MachineApplicable,
5012 } else if !self.check_for_cast(err, expr, found, expected) {
5013 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5017 let methods = self.get_conversion_methods(expr.span, expected, found);
5018 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5019 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5020 .filter_map(|(receiver, method)| {
5021 let method_call = format!(".{}()", method.ident);
5022 if receiver.ends_with(&method_call) {
5023 None // do not suggest code that is already there (#53348)
5025 let method_call_list = [".to_vec()", ".to_string()"];
5026 let sugg = if receiver.ends_with(".clone()")
5027 && method_call_list.contains(&method_call.as_str()) {
5028 let max_len = receiver.rfind(".").unwrap();
5029 format!("{}{}", &receiver[..max_len], method_call)
5031 format!("{}{}", receiver, method_call)
5033 Some(if is_struct_pat_shorthand_field {
5034 format!("{}: {}", receiver, sugg)
5040 if suggestions.peek().is_some() {
5041 err.span_suggestions(
5043 "try using a conversion method",
5045 Applicability::MaybeIncorrect,
5052 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5056 /// bar_that_returns_u32()
5060 /// This routine checks if the return expression in a block would make sense on its own as a
5061 /// statement and the return type has been left as default or has been specified as `()`. If so,
5062 /// it suggests adding a semicolon.
5063 fn suggest_missing_semicolon(&self,
5064 err: &mut DiagnosticBuilder<'tcx>,
5065 expression: &'gcx hir::Expr,
5068 if expected.is_unit() {
5069 // `BlockTailExpression` only relevant if the tail expr would be
5070 // useful on its own.
5071 match expression.node {
5072 ExprKind::Call(..) |
5073 ExprKind::MethodCall(..) |
5074 ExprKind::While(..) |
5075 ExprKind::Loop(..) |
5076 ExprKind::Match(..) |
5077 ExprKind::Block(..) => {
5078 let sp = self.tcx.sess.source_map().next_point(cause_span);
5079 err.span_suggestion(
5081 "try adding a semicolon",
5083 Applicability::MachineApplicable);
5090 /// A possible error is to forget to add a return type that is needed:
5094 /// bar_that_returns_u32()
5098 /// This routine checks if the return type is left as default, the method is not part of an
5099 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5101 fn suggest_missing_return_type(
5103 err: &mut DiagnosticBuilder<'tcx>,
5104 fn_decl: &hir::FnDecl,
5109 // Only suggest changing the return type for methods that
5110 // haven't set a return type at all (and aren't `fn main()` or an impl).
5111 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5112 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5113 err.span_suggestion(
5115 "try adding a return type",
5116 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5117 Applicability::MachineApplicable);
5120 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5121 err.span_label(span, "possibly return type missing here?");
5124 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5125 // `fn main()` must return `()`, do not suggest changing return type
5126 err.span_label(span, "expected `()` because of default return type");
5129 // expectation was caused by something else, not the default return
5130 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5131 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5132 // Only point to return type if the expected type is the return type, as if they
5133 // are not, the expectation must have been caused by something else.
5134 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5136 let ty = AstConv::ast_ty_to_ty(self, ty);
5137 debug!("suggest_missing_return_type: return type {:?}", ty);
5138 debug!("suggest_missing_return_type: expected type {:?}", ty);
5139 if ty.sty == expected.sty {
5140 err.span_label(sp, format!("expected `{}` because of return type",
5149 /// A common error is to add an extra semicolon:
5152 /// fn foo() -> usize {
5157 /// This routine checks if the final statement in a block is an
5158 /// expression with an explicit semicolon whose type is compatible
5159 /// with `expected_ty`. If so, it suggests removing the semicolon.
5160 fn consider_hint_about_removing_semicolon(
5162 blk: &'gcx hir::Block,
5163 expected_ty: Ty<'tcx>,
5164 err: &mut DiagnosticBuilder<'_>,
5166 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5167 err.span_suggestion(
5169 "consider removing this semicolon",
5171 Applicability::MachineApplicable,
5176 fn could_remove_semicolon(
5178 blk: &'gcx hir::Block,
5179 expected_ty: Ty<'tcx>,
5181 // Be helpful when the user wrote `{... expr;}` and
5182 // taking the `;` off is enough to fix the error.
5183 let last_stmt = blk.stmts.last()?;
5184 let last_expr = match last_stmt.node {
5185 hir::StmtKind::Semi(ref e) => e,
5188 let last_expr_ty = self.node_ty(last_expr.hir_id);
5189 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5192 let original_span = original_sp(last_stmt.span, blk.span);
5193 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5196 // Rewrite `SelfCtor` to `Ctor`
5197 pub fn rewrite_self_ctor(
5201 ) -> Result<Res, ErrorReported> {
5203 if let Res::SelfCtor(impl_def_id) = res {
5204 let ty = self.impl_self_ty(span, impl_def_id).ty;
5205 let adt_def = ty.ty_adt_def();
5208 Some(adt_def) if adt_def.has_ctor() => {
5209 let variant = adt_def.non_enum_variant();
5210 let ctor_def_id = variant.ctor_def_id.unwrap();
5211 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5214 let mut err = tcx.sess.struct_span_err(span,
5215 "the `Self` constructor can only be used with tuple or unit structs");
5216 if let Some(adt_def) = adt_def {
5217 match adt_def.adt_kind() {
5219 err.help("did you mean to use one of the enum's variants?");
5223 err.span_suggestion(
5225 "use curly brackets",
5226 String::from("Self { /* fields */ }"),
5227 Applicability::HasPlaceholders,
5242 // Instantiates the given path, which must refer to an item with the given
5243 // number of type parameters and type.
5244 pub fn instantiate_value_path(&self,
5245 segments: &[hir::PathSegment],
5246 self_ty: Option<Ty<'tcx>>,
5250 -> (Ty<'tcx>, Res) {
5252 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5261 let res = match self.rewrite_self_ctor(res, span) {
5263 Err(ErrorReported) => return (tcx.types.err, res),
5265 let path_segs = match res {
5266 Res::Local(_) | Res::Upvar(..) => Vec::new(),
5267 Res::Def(kind, def_id) =>
5268 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5269 _ => bug!("instantiate_value_path on {:?}", res),
5272 let mut user_self_ty = None;
5273 let mut is_alias_variant_ctor = false;
5275 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5276 if let Some(self_ty) = self_ty {
5277 let adt_def = self_ty.ty_adt_def().unwrap();
5278 user_self_ty = Some(UserSelfTy {
5279 impl_def_id: adt_def.did,
5282 is_alias_variant_ctor = true;
5285 Res::Def(DefKind::Method, def_id)
5286 | Res::Def(DefKind::AssocConst, def_id) => {
5287 let container = tcx.associated_item(def_id).container;
5288 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5290 ty::TraitContainer(trait_did) => {
5291 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5293 ty::ImplContainer(impl_def_id) => {
5294 if segments.len() == 1 {
5295 // `<T>::assoc` will end up here, and so
5296 // can `T::assoc`. It this came from an
5297 // inherent impl, we need to record the
5298 // `T` for posterity (see `UserSelfTy` for
5300 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5301 user_self_ty = Some(UserSelfTy {
5312 // Now that we have categorized what space the parameters for each
5313 // segment belong to, let's sort out the parameters that the user
5314 // provided (if any) into their appropriate spaces. We'll also report
5315 // errors if type parameters are provided in an inappropriate place.
5317 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5318 let generics_has_err = AstConv::prohibit_generics(
5319 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5320 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5328 Res::Local(hid) | Res::Upvar(hid, ..) => {
5329 let ty = self.local_ty(span, hid).decl_ty;
5330 let ty = self.normalize_associated_types_in(span, &ty);
5331 self.write_ty(hir_id, ty);
5337 if generics_has_err {
5338 // Don't try to infer type parameters when prohibited generic arguments were given.
5339 user_self_ty = None;
5342 // Now we have to compare the types that the user *actually*
5343 // provided against the types that were *expected*. If the user
5344 // did not provide any types, then we want to substitute inference
5345 // variables. If the user provided some types, we may still need
5346 // to add defaults. If the user provided *too many* types, that's
5349 let mut infer_args_for_err = FxHashSet::default();
5350 for &PathSeg(def_id, index) in &path_segs {
5351 let seg = &segments[index];
5352 let generics = tcx.generics_of(def_id);
5353 // Argument-position `impl Trait` is treated as a normal generic
5354 // parameter internally, but we don't allow users to specify the
5355 // parameter's value explicitly, so we have to do some error-
5357 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5362 false, // `is_method_call`
5364 if suppress_errors {
5365 infer_args_for_err.insert(index);
5366 self.set_tainted_by_errors(); // See issue #53251.
5370 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5371 tcx.generics_of(*def_id).has_self
5372 }).unwrap_or(false);
5374 let def_id = res.def_id();
5376 // The things we are substituting into the type should not contain
5377 // escaping late-bound regions, and nor should the base type scheme.
5378 let ty = tcx.type_of(def_id);
5380 let substs = AstConv::create_substs_for_generic_args(
5386 // Provide the generic args, and whether types should be inferred.
5388 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5391 // If we've encountered an `impl Trait`-related error, we're just
5392 // going to infer the arguments for better error messages.
5393 if !infer_args_for_err.contains(&index) {
5394 // Check whether the user has provided generic arguments.
5395 if let Some(ref data) = segments[index].args {
5396 return (Some(data), segments[index].infer_types);
5399 return (None, segments[index].infer_types);
5404 // Provide substitutions for parameters for which (valid) arguments have been provided.
5406 match (¶m.kind, arg) {
5407 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5408 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5410 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5411 self.to_ty(ty).into()
5413 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5414 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5416 _ => unreachable!(),
5419 // Provide substitutions for parameters for which arguments are inferred.
5420 |substs, param, infer_types| {
5422 GenericParamDefKind::Lifetime => {
5423 self.re_infer(span, Some(param)).unwrap().into()
5425 GenericParamDefKind::Type { has_default, .. } => {
5426 if !infer_types && has_default {
5427 // If we have a default, then we it doesn't matter that we're not
5428 // inferring the type arguments: we provide the default where any
5430 let default = tcx.type_of(param.def_id);
5433 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5436 // If no type arguments were provided, we have to infer them.
5437 // This case also occurs as a result of some malformed input, e.g.
5438 // a lifetime argument being given instead of a type parameter.
5439 // Using inference instead of `Error` gives better error messages.
5440 self.var_for_def(span, param)
5443 GenericParamDefKind::Const => {
5444 // FIXME(const_generics:defaults)
5445 // No const parameters were provided, we have to infer them.
5446 self.var_for_def(span, param)
5451 assert!(!substs.has_escaping_bound_vars());
5452 assert!(!ty.has_escaping_bound_vars());
5454 // First, store the "user substs" for later.
5455 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5457 // Add all the obligations that are required, substituting and
5458 // normalized appropriately.
5459 let bounds = self.instantiate_bounds(span, def_id, &substs);
5460 self.add_obligations_for_parameters(
5461 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5464 // Substitute the values for the type parameters into the type of
5465 // the referenced item.
5466 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5468 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5469 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5470 // is inherent, there is no `Self` parameter; instead, the impl needs
5471 // type parameters, which we can infer by unifying the provided `Self`
5472 // with the substituted impl type.
5473 // This also occurs for an enum variant on a type alias.
5474 let ty = tcx.type_of(impl_def_id);
5476 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5477 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5478 Ok(ok) => self.register_infer_ok_obligations(ok),
5480 self.tcx.sess.delay_span_bug(span, &format!(
5481 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5489 self.check_rustc_args_require_const(def_id, hir_id, span);
5491 debug!("instantiate_value_path: type of {:?} is {:?}",
5494 self.write_substs(hir_id, substs);
5496 (ty_substituted, res)
5499 fn check_rustc_args_require_const(&self,
5503 // We're only interested in functions tagged with
5504 // #[rustc_args_required_const], so ignore anything that's not.
5505 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5509 // If our calling expression is indeed the function itself, we're good!
5510 // If not, generate an error that this can only be called directly.
5511 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5512 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5514 if let ExprKind::Call(ref callee, ..) = expr.node {
5515 if callee.hir_id == hir_id {
5521 self.tcx.sess.span_err(span, "this function can only be invoked \
5522 directly, not through a function pointer");
5525 // Resolves `typ` by a single level if `typ` is a type variable.
5526 // If no resolution is possible, then an error is reported.
5527 // Numeric inference variables may be left unresolved.
5528 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5529 let ty = self.resolve_type_vars_with_obligations(ty);
5530 if !ty.is_ty_var() {
5533 if !self.is_tainted_by_errors() {
5534 self.need_type_info_err((**self).body_id, sp, ty)
5535 .note("type must be known at this point")
5538 self.demand_suptype(sp, self.tcx.types.err, ty);
5543 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5544 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5545 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5548 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5549 index = enclosing_breakables.stack.len();
5550 enclosing_breakables.by_id.insert(id, index);
5551 enclosing_breakables.stack.push(ctxt);
5555 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5556 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5557 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5558 enclosing_breakables.stack.pop().expect("missing breakable context")
5563 /// Instantiate a QueryResponse in a probe context, without a
5564 /// good ObligationCause.
5565 fn probe_instantiate_query_response(
5568 original_values: &OriginalQueryValues<'tcx>,
5569 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5570 ) -> InferResult<'tcx, Ty<'tcx>>
5572 self.instantiate_query_response_and_region_obligations(
5573 &traits::ObligationCause::misc(span, self.body_id),
5579 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5580 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5581 let mut contained_in_place = false;
5583 while let hir::Node::Expr(parent_expr) =
5584 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5586 match &parent_expr.node {
5587 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5588 if lhs.hir_id == expr_id {
5589 contained_in_place = true;
5595 expr_id = parent_expr.hir_id;
5602 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5603 generics: &ty::Generics,
5605 let own_counts = generics.own_counts();
5607 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5613 if own_counts.types == 0 {
5617 // Make a vector of booleans initially false, set to true when used.
5618 let mut types_used = vec![false; own_counts.types];
5620 for leaf_ty in ty.walk() {
5621 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5622 debug!("Found use of ty param num {}", index);
5623 types_used[index as usize - own_counts.lifetimes] = true;
5624 } else if let ty::Error = leaf_ty.sty {
5625 // If there is already another error, do not emit
5626 // an error for not using a type Parameter.
5627 assert!(tcx.sess.err_count() > 0);
5632 let types = generics.params.iter().filter(|param| match param.kind {
5633 ty::GenericParamDefKind::Type { .. } => true,
5636 for (&used, param) in types_used.iter().zip(types) {
5638 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5639 let span = tcx.hir().span_by_hir_id(id);
5640 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5641 .span_label(span, "unused type parameter")
5647 fn fatally_break_rust(sess: &Session) {
5648 let handler = sess.diagnostic();
5649 handler.span_bug_no_panic(
5651 "It looks like you're trying to break rust; would you like some ICE?",
5653 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5654 handler.note_without_error(
5655 "we would appreciate a joke overview: \
5656 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5658 handler.note_without_error(&format!("rustc {} running on {}",
5659 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5660 crate::session::config::host_triple(),
5664 fn potentially_plural_count(count: usize, word: &str) -> String {
5665 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })