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_and_get_scope(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| {
3514 self.tcx.adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id).1;
3515 field.vis.is_accessible_from(def_scope, self.tcx)
3517 .map(|field| field.ident.name)
3521 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3522 // dynamic limit, to never omit just one field
3523 let limit = if names.len() == 6 { 6 } else { 5 };
3524 let mut display = names.iter().take(limit)
3525 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3526 if names.len() > limit {
3527 display = format!("{} ... and {} others", display, names.len() - limit);
3532 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3533 -> DiagnosticBuilder<'_> {
3534 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3535 "no field `{}` on type `{}`",
3539 fn report_unknown_field(
3542 variant: &'tcx ty::VariantDef,
3544 skip_fields: &[hir::Field],
3547 if variant.recovered {
3550 let mut err = self.type_error_struct_with_diag(
3552 |actual| match ty.sty {
3553 ty::Adt(adt, ..) if adt.is_enum() => {
3554 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3555 "{} `{}::{}` has no field named `{}`",
3556 kind_name, actual, variant.ident, field.ident)
3559 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3560 "{} `{}` has no field named `{}`",
3561 kind_name, actual, field.ident)
3565 // prevent all specified fields from being suggested
3566 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3567 if let Some(field_name) = Self::suggest_field_name(variant,
3568 &field.ident.as_str(),
3569 skip_fields.collect()) {
3570 err.span_suggestion(
3572 "a field with a similar name exists",
3573 field_name.to_string(),
3574 Applicability::MaybeIncorrect,
3578 ty::Adt(adt, ..) => {
3580 err.span_label(field.ident.span,
3581 format!("`{}::{}` does not have this field",
3582 ty, variant.ident));
3584 err.span_label(field.ident.span,
3585 format!("`{}` does not have this field", ty));
3587 let available_field_names = self.available_field_names(variant);
3588 if !available_field_names.is_empty() {
3589 err.note(&format!("available fields are: {}",
3590 self.name_series_display(available_field_names)));
3593 _ => bug!("non-ADT passed to report_unknown_field")
3599 fn check_expr_struct_fields(&self,
3601 expected: Expectation<'tcx>,
3602 expr_id: hir::HirId,
3604 variant: &'tcx ty::VariantDef,
3605 ast_fields: &'gcx [hir::Field],
3606 check_completeness: bool) -> bool {
3610 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3611 .get(0).cloned().unwrap_or(adt_ty);
3612 // re-link the regions that EIfEO can erase.
3613 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3615 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3616 &ty::Adt(adt, substs) => {
3617 (substs, adt.adt_kind(), adt.variant_descr())
3619 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3622 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3623 (field.ident.modern(), (i, field))
3624 ).collect::<FxHashMap<_, _>>();
3626 let mut seen_fields = FxHashMap::default();
3628 let mut error_happened = false;
3630 // Type-check each field.
3631 for field in ast_fields {
3632 let ident = tcx.adjust_ident(field.ident, variant.def_id);
3633 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3634 seen_fields.insert(ident, field.span);
3635 self.write_field_index(field.hir_id, i);
3637 // We don't look at stability attributes on
3638 // struct-like enums (yet...), but it's definitely not
3639 // a bug to have constructed one.
3640 if adt_kind != AdtKind::Enum {
3641 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3644 self.field_ty(field.span, v_field, substs)
3646 error_happened = true;
3647 if let Some(prev_span) = seen_fields.get(&ident) {
3648 let mut err = struct_span_err!(self.tcx.sess,
3651 "field `{}` specified more than once",
3654 err.span_label(field.ident.span, "used more than once");
3655 err.span_label(*prev_span, format!("first use of `{}`", ident));
3659 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3665 // Make sure to give a type to the field even if there's
3666 // an error, so we can continue type-checking.
3667 self.check_expr_coercable_to_type(&field.expr, field_type);
3670 // Make sure the programmer specified correct number of fields.
3671 if kind_name == "union" {
3672 if ast_fields.len() != 1 {
3673 tcx.sess.span_err(span, "union expressions should have exactly one field");
3675 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3676 let len = remaining_fields.len();
3678 let mut displayable_field_names = remaining_fields
3680 .map(|ident| ident.as_str())
3681 .collect::<Vec<_>>();
3683 displayable_field_names.sort();
3685 let truncated_fields_error = if len <= 3 {
3688 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3691 let remaining_fields_names = displayable_field_names.iter().take(3)
3692 .map(|n| format!("`{}`", n))
3693 .collect::<Vec<_>>()
3696 struct_span_err!(tcx.sess, span, E0063,
3697 "missing field{} {}{} in initializer of `{}`",
3698 if remaining_fields.len() == 1 { "" } else { "s" },
3699 remaining_fields_names,
3700 truncated_fields_error,
3702 .span_label(span, format!("missing {}{}",
3703 remaining_fields_names,
3704 truncated_fields_error))
3710 fn check_struct_fields_on_error(&self,
3711 fields: &'gcx [hir::Field],
3712 base_expr: &'gcx Option<P<hir::Expr>>) {
3713 for field in fields {
3714 self.check_expr(&field.expr);
3716 if let Some(ref base) = *base_expr {
3717 self.check_expr(&base);
3721 pub fn check_struct_path(&self,
3724 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3725 let path_span = match *qpath {
3726 QPath::Resolved(_, ref path) => path.span,
3727 QPath::TypeRelative(ref qself, _) => qself.span
3729 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3730 let variant = match def {
3732 self.set_tainted_by_errors();
3735 Res::Def(DefKind::Variant, _) => {
3737 ty::Adt(adt, substs) => {
3738 Some((adt.variant_of_res(def), adt.did, substs))
3740 _ => bug!("unexpected type: {:?}", ty)
3743 Res::Def(DefKind::Struct, _)
3744 | Res::Def(DefKind::Union, _)
3745 | Res::Def(DefKind::TyAlias, _)
3746 | Res::Def(DefKind::AssocTy, _)
3747 | Res::SelfTy(..) => {
3749 ty::Adt(adt, substs) if !adt.is_enum() => {
3750 Some((adt.non_enum_variant(), adt.did, substs))
3755 _ => bug!("unexpected definition: {:?}", def)
3758 if let Some((variant, did, substs)) = variant {
3759 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3760 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3762 // Check bounds on type arguments used in the path.
3763 let bounds = self.instantiate_bounds(path_span, did, substs);
3764 let cause = traits::ObligationCause::new(path_span, self.body_id,
3765 traits::ItemObligation(did));
3766 self.add_obligations_for_parameters(cause, &bounds);
3770 struct_span_err!(self.tcx.sess, path_span, E0071,
3771 "expected struct, variant or union type, found {}",
3772 ty.sort_string(self.tcx))
3773 .span_label(path_span, "not a struct")
3779 fn check_expr_struct(&self,
3781 expected: Expectation<'tcx>,
3783 fields: &'gcx [hir::Field],
3784 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3786 // Find the relevant variant
3787 let (variant, adt_ty) =
3788 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3791 self.check_struct_fields_on_error(fields, base_expr);
3792 return self.tcx.types.err;
3795 let path_span = match *qpath {
3796 QPath::Resolved(_, ref path) => path.span,
3797 QPath::TypeRelative(ref qself, _) => qself.span
3800 // Prohibit struct expressions when non-exhaustive flag is set.
3801 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3802 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3803 span_err!(self.tcx.sess, expr.span, E0639,
3804 "cannot create non-exhaustive {} using struct expression",
3805 adt.variant_descr());
3808 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3809 variant, fields, base_expr.is_none());
3810 if let &Some(ref base_expr) = base_expr {
3811 // If check_expr_struct_fields hit an error, do not attempt to populate
3812 // the fields with the base_expr. This could cause us to hit errors later
3813 // when certain fields are assumed to exist that in fact do not.
3814 if !error_happened {
3815 self.check_expr_has_type_or_error(base_expr, adt_ty);
3817 ty::Adt(adt, substs) if adt.is_struct() => {
3818 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3819 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3824 .fru_field_types_mut()
3825 .insert(expr.hir_id, fru_field_types);
3828 span_err!(self.tcx.sess, base_expr.span, E0436,
3829 "functional record update syntax requires a struct");
3834 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3840 /// If an expression has any sub-expressions that result in a type error,
3841 /// inspecting that expression's type with `ty.references_error()` will return
3842 /// true. Likewise, if an expression is known to diverge, inspecting its
3843 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3844 /// strict, _|_ can appear in the type of an expression that does not,
3845 /// itself, diverge: for example, fn() -> _|_.)
3846 /// Note that inspecting a type's structure *directly* may expose the fact
3847 /// that there are actually multiple representations for `Error`, so avoid
3848 /// that when err needs to be handled differently.
3849 fn check_expr_with_expectation_and_needs(&self,
3850 expr: &'gcx hir::Expr,
3851 expected: Expectation<'tcx>,
3852 needs: Needs) -> Ty<'tcx> {
3853 debug!(">> type-checking: expr={:?} expected={:?}",
3856 // Warn for expressions after diverging siblings.
3857 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3859 // Hide the outer diverging and has_errors flags.
3860 let old_diverges = self.diverges.get();
3861 let old_has_errors = self.has_errors.get();
3862 self.diverges.set(Diverges::Maybe);
3863 self.has_errors.set(false);
3865 let ty = self.check_expr_kind(expr, expected, needs);
3867 // Warn for non-block expressions with diverging children.
3869 ExprKind::Block(..) |
3870 ExprKind::Loop(..) | ExprKind::While(..) |
3871 ExprKind::Match(..) => {}
3873 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3876 // Any expression that produces a value of type `!` must have diverged
3878 self.diverges.set(self.diverges.get() | Diverges::Always);
3881 // Record the type, which applies it effects.
3882 // We need to do this after the warning above, so that
3883 // we don't warn for the diverging expression itself.
3884 self.write_ty(expr.hir_id, ty);
3886 // Combine the diverging and has_error flags.
3887 self.diverges.set(self.diverges.get() | old_diverges);
3888 self.has_errors.set(self.has_errors.get() | old_has_errors);
3890 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3891 debug!("... {:?}, expected is {:?}", ty, expected);
3898 expr: &'gcx hir::Expr,
3899 expected: Expectation<'tcx>,
3903 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3910 let id = expr.hir_id;
3912 ExprKind::Box(ref subexpr) => {
3913 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3915 ty::Adt(def, _) if def.is_box()
3916 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3920 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3921 tcx.mk_box(referent_ty)
3924 ExprKind::Lit(ref lit) => {
3925 self.check_lit(&lit, expected)
3927 ExprKind::Binary(op, ref lhs, ref rhs) => {
3928 self.check_binop(expr, op, lhs, rhs)
3930 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3931 self.check_binop_assign(expr, op, lhs, rhs)
3933 ExprKind::Unary(unop, ref oprnd) => {
3934 let expected_inner = match unop {
3935 hir::UnNot | hir::UnNeg => {
3942 let needs = match unop {
3943 hir::UnDeref => needs,
3946 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3950 if !oprnd_t.references_error() {
3951 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3954 if let Some(mt) = oprnd_t.builtin_deref(true) {
3956 } else if let Some(ok) = self.try_overloaded_deref(
3957 expr.span, oprnd_t, needs) {
3958 let method = self.register_infer_ok_obligations(ok);
3959 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3960 let mutbl = match mutbl {
3961 hir::MutImmutable => AutoBorrowMutability::Immutable,
3962 hir::MutMutable => AutoBorrowMutability::Mutable {
3963 // (It shouldn't actually matter for unary ops whether
3964 // we enable two-phase borrows or not, since a unary
3965 // op has no additional operands.)
3966 allow_two_phase_borrow: AllowTwoPhase::No,
3969 self.apply_adjustments(oprnd, vec![Adjustment {
3970 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3971 target: method.sig.inputs()[0]
3974 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3975 self.write_method_call(expr.hir_id, method);
3977 let mut err = type_error_struct!(
3982 "type `{}` cannot be dereferenced",
3985 let sp = tcx.sess.source_map().start_point(expr.span);
3986 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
3989 tcx.sess.parse_sess.expr_parentheses_needed(
3996 oprnd_t = tcx.types.err;
4000 let result = self.check_user_unop(expr, oprnd_t, unop);
4001 // If it's builtin, we can reuse the type, this helps inference.
4002 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4007 let result = self.check_user_unop(expr, oprnd_t, unop);
4008 // If it's builtin, we can reuse the type, this helps inference.
4009 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4017 ExprKind::AddrOf(mutbl, ref oprnd) => {
4018 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4020 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4021 if oprnd.is_place_expr() {
4022 // Places may legitimately have unsized types.
4023 // For example, dereferences of a fat pointer and
4024 // the last field of a struct can be unsized.
4027 Expectation::rvalue_hint(self, ty)
4033 let needs = Needs::maybe_mut_place(mutbl);
4034 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4036 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4037 if tm.ty.references_error() {
4040 // Note: at this point, we cannot say what the best lifetime
4041 // is to use for resulting pointer. We want to use the
4042 // shortest lifetime possible so as to avoid spurious borrowck
4043 // errors. Moreover, the longest lifetime will depend on the
4044 // precise details of the value whose address is being taken
4045 // (and how long it is valid), which we don't know yet until type
4046 // inference is complete.
4048 // Therefore, here we simply generate a region variable. The
4049 // region inferencer will then select the ultimate value.
4050 // Finally, borrowck is charged with guaranteeing that the
4051 // value whose address was taken can actually be made to live
4052 // as long as it needs to live.
4053 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4054 tcx.mk_ref(region, tm)
4057 ExprKind::Path(ref qpath) => {
4058 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4060 let ty = match res {
4062 self.set_tainted_by_errors();
4065 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4066 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4069 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4072 if let ty::FnDef(..) = ty.sty {
4073 let fn_sig = ty.fn_sig(tcx);
4074 if !tcx.features().unsized_locals {
4075 // We want to remove some Sized bounds from std functions,
4076 // but don't want to expose the removal to stable Rust.
4077 // i.e., we don't want to allow
4083 // to work in stable even if the Sized bound on `drop` is relaxed.
4084 for i in 0..fn_sig.inputs().skip_binder().len() {
4085 // We just want to check sizedness, so instead of introducing
4086 // placeholder lifetimes with probing, we just replace higher lifetimes
4088 let input = self.replace_bound_vars_with_fresh_vars(
4090 infer::LateBoundRegionConversionTime::FnCall,
4091 &fn_sig.input(i)).0;
4092 self.require_type_is_sized_deferred(input, expr.span,
4093 traits::SizedArgumentType);
4096 // Here we want to prevent struct constructors from returning unsized types.
4097 // There were two cases this happened: fn pointer coercion in stable
4098 // and usual function call in presense of unsized_locals.
4099 // Also, as we just want to check sizedness, instead of introducing
4100 // placeholder lifetimes with probing, we just replace higher lifetimes
4102 let output = self.replace_bound_vars_with_fresh_vars(
4104 infer::LateBoundRegionConversionTime::FnCall,
4105 &fn_sig.output()).0;
4106 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4109 // We always require that the type provided as the value for
4110 // a type parameter outlives the moment of instantiation.
4111 let substs = self.tables.borrow().node_substs(expr.hir_id);
4112 self.add_wf_bounds(substs, expr);
4116 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4117 for expr in outputs.iter().chain(inputs.iter()) {
4118 self.check_expr(expr);
4122 ExprKind::Break(destination, ref expr_opt) => {
4123 if let Ok(target_id) = destination.target_id {
4125 if let Some(ref e) = *expr_opt {
4126 // If this is a break with a value, we need to type-check
4127 // the expression. Get an expected type from the loop context.
4128 let opt_coerce_to = {
4129 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4130 enclosing_breakables.find_breakable(target_id)
4133 .map(|coerce| coerce.expected_ty())
4136 // If the loop context is not a `loop { }`, then break with
4137 // a value is illegal, and `opt_coerce_to` will be `None`.
4138 // Just set expectation to error in that case.
4139 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4141 // Recurse without `enclosing_breakables` borrowed.
4142 e_ty = self.check_expr_with_hint(e, coerce_to);
4143 cause = self.misc(e.span);
4145 // Otherwise, this is a break *without* a value. That's
4146 // always legal, and is equivalent to `break ()`.
4147 e_ty = tcx.mk_unit();
4148 cause = self.misc(expr.span);
4151 // Now that we have type-checked `expr_opt`, borrow
4152 // the `enclosing_loops` field and let's coerce the
4153 // type of `expr_opt` into what is expected.
4154 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4155 let ctxt = enclosing_breakables.find_breakable(target_id);
4156 if let Some(ref mut coerce) = ctxt.coerce {
4157 if let Some(ref e) = *expr_opt {
4158 coerce.coerce(self, &cause, e, e_ty);
4160 assert!(e_ty.is_unit());
4161 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4164 // If `ctxt.coerce` is `None`, we can just ignore
4165 // the type of the expresison. This is because
4166 // either this was a break *without* a value, in
4167 // which case it is always a legal type (`()`), or
4168 // else an error would have been flagged by the
4169 // `loops` pass for using break with an expression
4170 // where you are not supposed to.
4171 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4174 ctxt.may_break = true;
4176 // the type of a `break` is always `!`, since it diverges
4179 // Otherwise, we failed to find the enclosing loop;
4180 // this can only happen if the `break` was not
4181 // inside a loop at all, which is caught by the
4182 // loop-checking pass.
4183 if self.tcx.sess.err_count() == 0 {
4184 self.tcx.sess.delay_span_bug(expr.span,
4185 "break was outside loop, but no error was emitted");
4188 // We still need to assign a type to the inner expression to
4189 // prevent the ICE in #43162.
4190 if let Some(ref e) = *expr_opt {
4191 self.check_expr_with_hint(e, tcx.types.err);
4193 // ... except when we try to 'break rust;'.
4194 // ICE this expression in particular (see #43162).
4195 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4196 if path.segments.len() == 1 &&
4197 path.segments[0].ident.name == sym::rust {
4198 fatally_break_rust(self.tcx.sess);
4202 // There was an error; make type-check fail.
4207 ExprKind::Continue(destination) => {
4208 if destination.target_id.is_ok() {
4211 // There was an error; make type-check fail.
4215 ExprKind::Ret(ref expr_opt) => {
4216 if self.ret_coercion.is_none() {
4217 struct_span_err!(self.tcx.sess, expr.span, E0572,
4218 "return statement outside of function body").emit();
4219 } else if let Some(ref e) = *expr_opt {
4220 if self.ret_coercion_span.borrow().is_none() {
4221 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4223 self.check_return_expr(e);
4225 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4226 if self.ret_coercion_span.borrow().is_none() {
4227 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4229 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4230 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4231 coercion.coerce_forced_unit(
4236 fn_decl.output.span(),
4238 "expected `{}` because of this return type",
4246 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4251 ExprKind::Assign(ref lhs, ref rhs) => {
4252 self.check_assign(expr, expected, lhs, rhs)
4254 ExprKind::While(ref cond, ref body, _) => {
4255 let ctxt = BreakableCtxt {
4256 // cannot use break with a value from a while loop
4258 may_break: false, // Will get updated if/when we find a `break`.
4261 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4262 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4263 let cond_diverging = self.diverges.get();
4264 self.check_block_no_value(&body);
4266 // We may never reach the body so it diverging means nothing.
4267 self.diverges.set(cond_diverging);
4271 // No way to know whether it's diverging because
4272 // of a `break` or an outer `break` or `return`.
4273 self.diverges.set(Diverges::Maybe);
4278 ExprKind::Loop(ref body, _, source) => {
4279 let coerce = match source {
4280 // you can only use break with a value from a normal `loop { }`
4281 hir::LoopSource::Loop => {
4282 let coerce_to = expected.coercion_target_type(self, body.span);
4283 Some(CoerceMany::new(coerce_to))
4286 hir::LoopSource::WhileLet |
4287 hir::LoopSource::ForLoop => {
4292 let ctxt = BreakableCtxt {
4294 may_break: false, // Will get updated if/when we find a `break`.
4297 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4298 self.check_block_no_value(&body);
4302 // No way to know whether it's diverging because
4303 // of a `break` or an outer `break` or `return`.
4304 self.diverges.set(Diverges::Maybe);
4307 // If we permit break with a value, then result type is
4308 // the LUB of the breaks (possibly ! if none); else, it
4309 // is nil. This makes sense because infinite loops
4310 // (which would have type !) are only possible iff we
4311 // permit break with a value [1].
4312 if ctxt.coerce.is_none() && !ctxt.may_break {
4314 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4316 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4318 ExprKind::Match(ref discrim, ref arms, match_src) => {
4319 self.check_match(expr, &discrim, arms, expected, match_src)
4321 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4322 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4324 ExprKind::Block(ref body, _) => {
4325 self.check_block_with_expected(&body, expected)
4327 ExprKind::Call(ref callee, ref args) => {
4328 self.check_call(expr, &callee, args, expected)
4330 ExprKind::MethodCall(ref segment, span, ref args) => {
4331 self.check_method_call(expr, segment, span, args, expected, needs)
4333 ExprKind::Cast(ref e, ref t) => {
4334 // Find the type of `e`. Supply hints based on the type we are casting to,
4336 let t_cast = self.to_ty_saving_user_provided_ty(t);
4337 let t_cast = self.resolve_vars_if_possible(&t_cast);
4338 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4339 let t_cast = self.resolve_vars_if_possible(&t_cast);
4341 // Eagerly check for some obvious errors.
4342 if t_expr.references_error() || t_cast.references_error() {
4345 // Defer other checks until we're done type checking.
4346 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4347 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4349 deferred_cast_checks.push(cast_check);
4352 Err(ErrorReported) => {
4358 ExprKind::Type(ref e, ref t) => {
4359 let ty = self.to_ty_saving_user_provided_ty(&t);
4360 self.check_expr_eq_type(&e, ty);
4363 ExprKind::DropTemps(ref e) => {
4364 self.check_expr_with_expectation(e, expected)
4366 ExprKind::Array(ref args) => {
4367 let uty = expected.to_option(self).and_then(|uty| {
4369 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4374 let element_ty = if !args.is_empty() {
4375 let coerce_to = uty.unwrap_or_else(
4376 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4377 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4378 assert_eq!(self.diverges.get(), Diverges::Maybe);
4380 let e_ty = self.check_expr_with_hint(e, coerce_to);
4381 let cause = self.misc(e.span);
4382 coerce.coerce(self, &cause, e, e_ty);
4384 coerce.complete(self)
4386 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4388 tcx.mk_array(element_ty, args.len() as u64)
4390 ExprKind::Repeat(ref element, ref count) => {
4391 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4392 let param_env = ty::ParamEnv::empty();
4393 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4394 let instance = ty::Instance::resolve(
4400 let global_id = GlobalId {
4404 let count = tcx.const_eval(param_env.and(global_id));
4406 let uty = match expected {
4407 ExpectHasType(uty) => {
4409 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4416 let (element_ty, t) = match uty {
4418 self.check_expr_coercable_to_type(&element, uty);
4422 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4423 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4428 if let Ok(count) = count {
4429 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4431 // For [foo, ..n] where n > 1, `foo` must have
4433 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4434 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4438 if element_ty.references_error() {
4440 } else if let Ok(count) = count {
4441 tcx.mk_ty(ty::Array(t, count))
4446 ExprKind::Tup(ref elts) => {
4447 let flds = expected.only_has_type(self).and_then(|ty| {
4448 let ty = self.resolve_type_vars_with_obligations(ty);
4450 ty::Tuple(ref flds) => Some(&flds[..]),
4455 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4456 let t = match flds {
4457 Some(ref fs) if i < fs.len() => {
4458 let ety = fs[i].expect_ty();
4459 self.check_expr_coercable_to_type(&e, ety);
4463 self.check_expr_with_expectation(&e, NoExpectation)
4468 let tuple = tcx.mk_tup(elt_ts_iter);
4469 if tuple.references_error() {
4472 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4476 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4477 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4479 ExprKind::Field(ref base, field) => {
4480 self.check_field(expr, needs, &base, field)
4482 ExprKind::Index(ref base, ref idx) => {
4483 let base_t = self.check_expr_with_needs(&base, needs);
4484 let idx_t = self.check_expr(&idx);
4486 if base_t.references_error() {
4488 } else if idx_t.references_error() {
4491 let base_t = self.structurally_resolved_type(base.span, base_t);
4492 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4493 Some((index_ty, element_ty)) => {
4494 // two-phase not needed because index_ty is never mutable
4495 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4500 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4501 "cannot index into a value of type `{}`",
4503 // Try to give some advice about indexing tuples.
4504 if let ty::Tuple(..) = base_t.sty {
4505 let mut needs_note = true;
4506 // If the index is an integer, we can show the actual
4507 // fixed expression:
4508 if let ExprKind::Lit(ref lit) = idx.node {
4509 if let ast::LitKind::Int(i,
4510 ast::LitIntType::Unsuffixed) = lit.node {
4511 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4512 if let Ok(snip) = snip {
4513 err.span_suggestion(
4515 "to access tuple elements, use",
4516 format!("{}.{}", snip, i),
4517 Applicability::MachineApplicable,
4524 err.help("to access tuple elements, use tuple indexing \
4525 syntax (e.g., `tuple.0`)");
4534 ExprKind::Yield(ref value) => {
4535 match self.yield_ty {
4537 self.check_expr_coercable_to_type(&value, ty);
4540 struct_span_err!(self.tcx.sess, expr.span, E0627,
4541 "yield statement outside of generator literal").emit();
4546 hir::ExprKind::Err => {
4552 /// Type check assignment expression `expr` of form `lhs = rhs`.
4553 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4556 expr: &'gcx hir::Expr,
4557 expected: Expectation<'tcx>,
4558 lhs: &'gcx hir::Expr,
4559 rhs: &'gcx hir::Expr,
4561 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4562 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4564 let expected_ty = expected.coercion_target_type(self, expr.span);
4565 if expected_ty == self.tcx.types.bool {
4566 // The expected type is `bool` but this will result in `()` so we can reasonably
4567 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4568 // The likely cause of this is `if foo = bar { .. }`.
4569 let actual_ty = self.tcx.mk_unit();
4570 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4571 let msg = "try comparing for equality";
4572 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4573 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4574 if let (Ok(left), Ok(right)) = (left, right) {
4575 let help = format!("{} == {}", left, right);
4576 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4581 } else if !lhs.is_place_expr() {
4582 struct_span_err!(self.tcx.sess, expr.span, E0070,
4583 "invalid left-hand side expression")
4584 .span_label(expr.span, "left-hand of expression not valid")
4588 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4590 if lhs_ty.references_error() || rhs_ty.references_error() {
4597 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4598 // The newly resolved definition is written into `type_dependent_defs`.
4599 fn finish_resolving_struct_path(&self,
4606 QPath::Resolved(ref maybe_qself, ref path) => {
4607 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4608 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4611 QPath::TypeRelative(ref qself, ref segment) => {
4612 let ty = self.to_ty(qself);
4614 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4619 let result = AstConv::associated_path_to_ty(
4628 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4629 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4631 // Write back the new resolution.
4632 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4634 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4639 /// Resolves associated value path into a base type and associated constant or method
4640 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4641 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4645 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4647 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4648 let (ty, qself, item_segment) = match *qpath {
4649 QPath::Resolved(ref opt_qself, ref path) => {
4651 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4652 &path.segments[..]);
4654 QPath::TypeRelative(ref qself, ref segment) => {
4655 (self.to_ty(qself), qself, segment)
4658 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4659 // Return directly on cache hit. This is useful to avoid doubly reporting
4660 // errors with default match binding modes. See #44614.
4661 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4662 .unwrap_or(Res::Err);
4663 return (def, Some(ty), slice::from_ref(&**item_segment));
4665 let item_name = item_segment.ident;
4666 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4667 let result = match error {
4668 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4669 _ => Err(ErrorReported),
4671 if item_name.name != kw::Invalid {
4672 self.report_method_error(
4676 SelfSource::QPath(qself),
4684 // Write back the new resolution.
4685 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4687 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4689 slice::from_ref(&**item_segment),
4693 pub fn check_decl_initializer(&self,
4694 local: &'gcx hir::Local,
4695 init: &'gcx hir::Expr) -> Ty<'tcx>
4697 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4698 // for #42640 (default match binding modes).
4701 let ref_bindings = local.pat.contains_explicit_ref_binding();
4703 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4704 if let Some(m) = ref_bindings {
4705 // Somewhat subtle: if we have a `ref` binding in the pattern,
4706 // we want to avoid introducing coercions for the RHS. This is
4707 // both because it helps preserve sanity and, in the case of
4708 // ref mut, for soundness (issue #23116). In particular, in
4709 // the latter case, we need to be clear that the type of the
4710 // referent for the reference that results is *equal to* the
4711 // type of the place it is referencing, and not some
4712 // supertype thereof.
4713 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4714 self.demand_eqtype(init.span, local_ty, init_ty);
4717 self.check_expr_coercable_to_type(init, local_ty)
4721 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4722 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4723 self.write_ty(local.hir_id, t);
4725 if let Some(ref init) = local.init {
4726 let init_ty = self.check_decl_initializer(local, &init);
4727 if init_ty.references_error() {
4728 self.write_ty(local.hir_id, init_ty);
4732 self.check_pat_walk(
4735 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4738 let pat_ty = self.node_ty(local.pat.hir_id);
4739 if pat_ty.references_error() {
4740 self.write_ty(local.hir_id, pat_ty);
4744 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4745 // Don't do all the complex logic below for `DeclItem`.
4747 hir::StmtKind::Item(..) => return,
4748 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4751 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4753 // Hide the outer diverging and `has_errors` flags.
4754 let old_diverges = self.diverges.get();
4755 let old_has_errors = self.has_errors.get();
4756 self.diverges.set(Diverges::Maybe);
4757 self.has_errors.set(false);
4760 hir::StmtKind::Local(ref l) => {
4761 self.check_decl_local(&l);
4764 hir::StmtKind::Item(_) => {}
4765 hir::StmtKind::Expr(ref expr) => {
4766 // Check with expected type of `()`.
4767 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4769 hir::StmtKind::Semi(ref expr) => {
4770 self.check_expr(&expr);
4774 // Combine the diverging and `has_error` flags.
4775 self.diverges.set(self.diverges.get() | old_diverges);
4776 self.has_errors.set(self.has_errors.get() | old_has_errors);
4779 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4780 let unit = self.tcx.mk_unit();
4781 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4783 // if the block produces a `!` value, that can always be
4784 // (effectively) coerced to unit.
4786 self.demand_suptype(blk.span, unit, ty);
4790 fn check_block_with_expected(&self,
4791 blk: &'gcx hir::Block,
4792 expected: Expectation<'tcx>) -> Ty<'tcx> {
4794 let mut fcx_ps = self.ps.borrow_mut();
4795 let unsafety_state = fcx_ps.recurse(blk);
4796 replace(&mut *fcx_ps, unsafety_state)
4799 // In some cases, blocks have just one exit, but other blocks
4800 // can be targeted by multiple breaks. This can happen both
4801 // with labeled blocks as well as when we desugar
4802 // a `try { ... }` expression.
4806 // 'a: { if true { break 'a Err(()); } Ok(()) }
4808 // Here we would wind up with two coercions, one from
4809 // `Err(())` and the other from the tail expression
4810 // `Ok(())`. If the tail expression is omitted, that's a
4811 // "forced unit" -- unless the block diverges, in which
4812 // case we can ignore the tail expression (e.g., `'a: {
4813 // break 'a 22; }` would not force the type of the block
4815 let tail_expr = blk.expr.as_ref();
4816 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4817 let coerce = if blk.targeted_by_break {
4818 CoerceMany::new(coerce_to_ty)
4820 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4821 Some(e) => slice::from_ref(e),
4824 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4827 let prev_diverges = self.diverges.get();
4828 let ctxt = BreakableCtxt {
4829 coerce: Some(coerce),
4833 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4834 for s in &blk.stmts {
4838 // check the tail expression **without** holding the
4839 // `enclosing_breakables` lock below.
4840 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4842 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4843 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4844 let coerce = ctxt.coerce.as_mut().unwrap();
4845 if let Some(tail_expr_ty) = tail_expr_ty {
4846 let tail_expr = tail_expr.unwrap();
4847 let cause = self.cause(tail_expr.span,
4848 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4854 // Subtle: if there is no explicit tail expression,
4855 // that is typically equivalent to a tail expression
4856 // of `()` -- except if the block diverges. In that
4857 // case, there is no value supplied from the tail
4858 // expression (assuming there are no other breaks,
4859 // this implies that the type of the block will be
4862 // #41425 -- label the implicit `()` as being the
4863 // "found type" here, rather than the "expected type".
4864 if !self.diverges.get().always() {
4865 // #50009 -- Do not point at the entire fn block span, point at the return type
4866 // span, as it is the cause of the requirement, and
4867 // `consider_hint_about_removing_semicolon` will point at the last expression
4868 // if it were a relevant part of the error. This improves usability in editors
4869 // that highlight errors inline.
4870 let mut sp = blk.span;
4871 let mut fn_span = None;
4872 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4873 let ret_sp = decl.output.span();
4874 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4875 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4876 // output would otherwise be incorrect and even misleading. Make sure
4877 // the span we're aiming at correspond to a `fn` body.
4878 if block_sp == blk.span {
4880 fn_span = Some(ident.span);
4884 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4885 if let Some(expected_ty) = expected.only_has_type(self) {
4886 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4888 if let Some(fn_span) = fn_span {
4889 err.span_label(fn_span, "this function's body doesn't return");
4897 // If we can break from the block, then the block's exit is always reachable
4898 // (... as long as the entry is reachable) - regardless of the tail of the block.
4899 self.diverges.set(prev_diverges);
4902 let mut ty = ctxt.coerce.unwrap().complete(self);
4904 if self.has_errors.get() || ty.references_error() {
4905 ty = self.tcx.types.err
4908 self.write_ty(blk.hir_id, ty);
4910 *self.ps.borrow_mut() = prev;
4914 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4915 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4917 Node::Item(&hir::Item {
4918 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4920 Node::ImplItem(&hir::ImplItem {
4921 node: hir::ImplItemKind::Method(_, body_id), ..
4923 let body = self.tcx.hir().body(body_id);
4924 if let ExprKind::Block(block, _) = &body.value.node {
4925 return Some(block.span);
4933 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4934 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4935 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4936 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4939 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4940 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4942 Node::Item(&hir::Item {
4943 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4944 }) => decl.clone().and_then(|decl| {
4945 // This is less than ideal, it will not suggest a return type span on any
4946 // method called `main`, regardless of whether it is actually the entry point,
4947 // but it will still present it as the reason for the expected type.
4948 Some((decl, ident, ident.name != sym::main))
4950 Node::TraitItem(&hir::TraitItem {
4951 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4954 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
4955 Node::ImplItem(&hir::ImplItem {
4956 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4959 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
4964 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4965 /// suggestion can be made, `None` otherwise.
4966 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
4967 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4968 // `while` before reaching it, as block tail returns are not available in them.
4969 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4970 let parent = self.tcx.hir().get_by_hir_id(blk_id);
4971 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4975 /// On implicit return expressions with mismatched types, provides the following suggestions:
4977 /// - Points out the method's return type as the reason for the expected type.
4978 /// - Possible missing semicolon.
4979 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4980 pub fn suggest_mismatched_types_on_tail(
4982 err: &mut DiagnosticBuilder<'tcx>,
4983 expression: &'gcx hir::Expr,
4989 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4990 let mut pointing_at_return_type = false;
4991 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4992 pointing_at_return_type = self.suggest_missing_return_type(
4993 err, &fn_decl, expected, found, can_suggest);
4995 self.suggest_ref_or_into(err, expression, expected, found);
4996 pointing_at_return_type
4999 pub fn suggest_ref_or_into(
5001 err: &mut DiagnosticBuilder<'tcx>,
5006 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5007 err.span_suggestion(
5011 Applicability::MachineApplicable,
5013 } else if !self.check_for_cast(err, expr, found, expected) {
5014 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5018 let methods = self.get_conversion_methods(expr.span, expected, found);
5019 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5020 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5021 .filter_map(|(receiver, method)| {
5022 let method_call = format!(".{}()", method.ident);
5023 if receiver.ends_with(&method_call) {
5024 None // do not suggest code that is already there (#53348)
5026 let method_call_list = [".to_vec()", ".to_string()"];
5027 let sugg = if receiver.ends_with(".clone()")
5028 && method_call_list.contains(&method_call.as_str()) {
5029 let max_len = receiver.rfind(".").unwrap();
5030 format!("{}{}", &receiver[..max_len], method_call)
5032 format!("{}{}", receiver, method_call)
5034 Some(if is_struct_pat_shorthand_field {
5035 format!("{}: {}", receiver, sugg)
5041 if suggestions.peek().is_some() {
5042 err.span_suggestions(
5044 "try using a conversion method",
5046 Applicability::MaybeIncorrect,
5053 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5057 /// bar_that_returns_u32()
5061 /// This routine checks if the return expression in a block would make sense on its own as a
5062 /// statement and the return type has been left as default or has been specified as `()`. If so,
5063 /// it suggests adding a semicolon.
5064 fn suggest_missing_semicolon(&self,
5065 err: &mut DiagnosticBuilder<'tcx>,
5066 expression: &'gcx hir::Expr,
5069 if expected.is_unit() {
5070 // `BlockTailExpression` only relevant if the tail expr would be
5071 // useful on its own.
5072 match expression.node {
5073 ExprKind::Call(..) |
5074 ExprKind::MethodCall(..) |
5075 ExprKind::While(..) |
5076 ExprKind::Loop(..) |
5077 ExprKind::Match(..) |
5078 ExprKind::Block(..) => {
5079 let sp = self.tcx.sess.source_map().next_point(cause_span);
5080 err.span_suggestion(
5082 "try adding a semicolon",
5084 Applicability::MachineApplicable);
5091 /// A possible error is to forget to add a return type that is needed:
5095 /// bar_that_returns_u32()
5099 /// This routine checks if the return type is left as default, the method is not part of an
5100 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5102 fn suggest_missing_return_type(
5104 err: &mut DiagnosticBuilder<'tcx>,
5105 fn_decl: &hir::FnDecl,
5110 // Only suggest changing the return type for methods that
5111 // haven't set a return type at all (and aren't `fn main()` or an impl).
5112 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5113 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5114 err.span_suggestion(
5116 "try adding a return type",
5117 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5118 Applicability::MachineApplicable);
5121 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5122 err.span_label(span, "possibly return type missing here?");
5125 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5126 // `fn main()` must return `()`, do not suggest changing return type
5127 err.span_label(span, "expected `()` because of default return type");
5130 // expectation was caused by something else, not the default return
5131 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5132 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5133 // Only point to return type if the expected type is the return type, as if they
5134 // are not, the expectation must have been caused by something else.
5135 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5137 let ty = AstConv::ast_ty_to_ty(self, ty);
5138 debug!("suggest_missing_return_type: return type {:?}", ty);
5139 debug!("suggest_missing_return_type: expected type {:?}", ty);
5140 if ty.sty == expected.sty {
5141 err.span_label(sp, format!("expected `{}` because of return type",
5150 /// A common error is to add an extra semicolon:
5153 /// fn foo() -> usize {
5158 /// This routine checks if the final statement in a block is an
5159 /// expression with an explicit semicolon whose type is compatible
5160 /// with `expected_ty`. If so, it suggests removing the semicolon.
5161 fn consider_hint_about_removing_semicolon(
5163 blk: &'gcx hir::Block,
5164 expected_ty: Ty<'tcx>,
5165 err: &mut DiagnosticBuilder<'_>,
5167 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5168 err.span_suggestion(
5170 "consider removing this semicolon",
5172 Applicability::MachineApplicable,
5177 fn could_remove_semicolon(
5179 blk: &'gcx hir::Block,
5180 expected_ty: Ty<'tcx>,
5182 // Be helpful when the user wrote `{... expr;}` and
5183 // taking the `;` off is enough to fix the error.
5184 let last_stmt = blk.stmts.last()?;
5185 let last_expr = match last_stmt.node {
5186 hir::StmtKind::Semi(ref e) => e,
5189 let last_expr_ty = self.node_ty(last_expr.hir_id);
5190 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5193 let original_span = original_sp(last_stmt.span, blk.span);
5194 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5197 // Rewrite `SelfCtor` to `Ctor`
5198 pub fn rewrite_self_ctor(
5202 ) -> Result<Res, ErrorReported> {
5204 if let Res::SelfCtor(impl_def_id) = res {
5205 let ty = self.impl_self_ty(span, impl_def_id).ty;
5206 let adt_def = ty.ty_adt_def();
5209 Some(adt_def) if adt_def.has_ctor() => {
5210 let variant = adt_def.non_enum_variant();
5211 let ctor_def_id = variant.ctor_def_id.unwrap();
5212 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5215 let mut err = tcx.sess.struct_span_err(span,
5216 "the `Self` constructor can only be used with tuple or unit structs");
5217 if let Some(adt_def) = adt_def {
5218 match adt_def.adt_kind() {
5220 err.help("did you mean to use one of the enum's variants?");
5224 err.span_suggestion(
5226 "use curly brackets",
5227 String::from("Self { /* fields */ }"),
5228 Applicability::HasPlaceholders,
5243 // Instantiates the given path, which must refer to an item with the given
5244 // number of type parameters and type.
5245 pub fn instantiate_value_path(&self,
5246 segments: &[hir::PathSegment],
5247 self_ty: Option<Ty<'tcx>>,
5251 -> (Ty<'tcx>, Res) {
5253 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5262 let res = match self.rewrite_self_ctor(res, span) {
5264 Err(ErrorReported) => return (tcx.types.err, res),
5266 let path_segs = match res {
5267 Res::Local(_) => vec![],
5268 Res::Def(kind, def_id) =>
5269 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5270 _ => bug!("instantiate_value_path on {:?}", res),
5273 let mut user_self_ty = None;
5274 let mut is_alias_variant_ctor = false;
5276 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5277 if let Some(self_ty) = self_ty {
5278 let adt_def = self_ty.ty_adt_def().unwrap();
5279 user_self_ty = Some(UserSelfTy {
5280 impl_def_id: adt_def.did,
5283 is_alias_variant_ctor = true;
5286 Res::Def(DefKind::Method, def_id)
5287 | Res::Def(DefKind::AssocConst, def_id) => {
5288 let container = tcx.associated_item(def_id).container;
5289 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5291 ty::TraitContainer(trait_did) => {
5292 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5294 ty::ImplContainer(impl_def_id) => {
5295 if segments.len() == 1 {
5296 // `<T>::assoc` will end up here, and so
5297 // can `T::assoc`. It this came from an
5298 // inherent impl, we need to record the
5299 // `T` for posterity (see `UserSelfTy` for
5301 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5302 user_self_ty = Some(UserSelfTy {
5313 // Now that we have categorized what space the parameters for each
5314 // segment belong to, let's sort out the parameters that the user
5315 // provided (if any) into their appropriate spaces. We'll also report
5316 // errors if type parameters are provided in an inappropriate place.
5318 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5319 let generics_has_err = AstConv::prohibit_generics(
5320 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5321 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5328 if let Res::Local(hid) = res {
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);
5335 if generics_has_err {
5336 // Don't try to infer type parameters when prohibited generic arguments were given.
5337 user_self_ty = None;
5340 // Now we have to compare the types that the user *actually*
5341 // provided against the types that were *expected*. If the user
5342 // did not provide any types, then we want to substitute inference
5343 // variables. If the user provided some types, we may still need
5344 // to add defaults. If the user provided *too many* types, that's
5347 let mut infer_args_for_err = FxHashSet::default();
5348 for &PathSeg(def_id, index) in &path_segs {
5349 let seg = &segments[index];
5350 let generics = tcx.generics_of(def_id);
5351 // Argument-position `impl Trait` is treated as a normal generic
5352 // parameter internally, but we don't allow users to specify the
5353 // parameter's value explicitly, so we have to do some error-
5355 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5360 false, // `is_method_call`
5362 if suppress_errors {
5363 infer_args_for_err.insert(index);
5364 self.set_tainted_by_errors(); // See issue #53251.
5368 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5369 tcx.generics_of(*def_id).has_self
5370 }).unwrap_or(false);
5372 let def_id = res.def_id();
5374 // The things we are substituting into the type should not contain
5375 // escaping late-bound regions, and nor should the base type scheme.
5376 let ty = tcx.type_of(def_id);
5378 let substs = AstConv::create_substs_for_generic_args(
5384 // Provide the generic args, and whether types should be inferred.
5386 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5389 // If we've encountered an `impl Trait`-related error, we're just
5390 // going to infer the arguments for better error messages.
5391 if !infer_args_for_err.contains(&index) {
5392 // Check whether the user has provided generic arguments.
5393 if let Some(ref data) = segments[index].args {
5394 return (Some(data), segments[index].infer_types);
5397 return (None, segments[index].infer_types);
5402 // Provide substitutions for parameters for which (valid) arguments have been provided.
5404 match (¶m.kind, arg) {
5405 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5406 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5408 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5409 self.to_ty(ty).into()
5411 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5412 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5414 _ => unreachable!(),
5417 // Provide substitutions for parameters for which arguments are inferred.
5418 |substs, param, infer_types| {
5420 GenericParamDefKind::Lifetime => {
5421 self.re_infer(span, Some(param)).unwrap().into()
5423 GenericParamDefKind::Type { has_default, .. } => {
5424 if !infer_types && has_default {
5425 // If we have a default, then we it doesn't matter that we're not
5426 // inferring the type arguments: we provide the default where any
5428 let default = tcx.type_of(param.def_id);
5431 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5434 // If no type arguments were provided, we have to infer them.
5435 // This case also occurs as a result of some malformed input, e.g.
5436 // a lifetime argument being given instead of a type parameter.
5437 // Using inference instead of `Error` gives better error messages.
5438 self.var_for_def(span, param)
5441 GenericParamDefKind::Const => {
5442 // FIXME(const_generics:defaults)
5443 // No const parameters were provided, we have to infer them.
5444 self.var_for_def(span, param)
5449 assert!(!substs.has_escaping_bound_vars());
5450 assert!(!ty.has_escaping_bound_vars());
5452 // First, store the "user substs" for later.
5453 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5455 // Add all the obligations that are required, substituting and
5456 // normalized appropriately.
5457 let bounds = self.instantiate_bounds(span, def_id, &substs);
5458 self.add_obligations_for_parameters(
5459 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5462 // Substitute the values for the type parameters into the type of
5463 // the referenced item.
5464 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5466 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5467 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5468 // is inherent, there is no `Self` parameter; instead, the impl needs
5469 // type parameters, which we can infer by unifying the provided `Self`
5470 // with the substituted impl type.
5471 // This also occurs for an enum variant on a type alias.
5472 let ty = tcx.type_of(impl_def_id);
5474 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5475 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5476 Ok(ok) => self.register_infer_ok_obligations(ok),
5478 self.tcx.sess.delay_span_bug(span, &format!(
5479 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5487 self.check_rustc_args_require_const(def_id, hir_id, span);
5489 debug!("instantiate_value_path: type of {:?} is {:?}",
5492 self.write_substs(hir_id, substs);
5494 (ty_substituted, res)
5497 fn check_rustc_args_require_const(&self,
5501 // We're only interested in functions tagged with
5502 // #[rustc_args_required_const], so ignore anything that's not.
5503 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5507 // If our calling expression is indeed the function itself, we're good!
5508 // If not, generate an error that this can only be called directly.
5509 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5510 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5512 if let ExprKind::Call(ref callee, ..) = expr.node {
5513 if callee.hir_id == hir_id {
5519 self.tcx.sess.span_err(span, "this function can only be invoked \
5520 directly, not through a function pointer");
5523 // Resolves `typ` by a single level if `typ` is a type variable.
5524 // If no resolution is possible, then an error is reported.
5525 // Numeric inference variables may be left unresolved.
5526 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5527 let ty = self.resolve_type_vars_with_obligations(ty);
5528 if !ty.is_ty_var() {
5531 if !self.is_tainted_by_errors() {
5532 self.need_type_info_err((**self).body_id, sp, ty)
5533 .note("type must be known at this point")
5536 self.demand_suptype(sp, self.tcx.types.err, ty);
5541 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5542 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5543 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5546 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5547 index = enclosing_breakables.stack.len();
5548 enclosing_breakables.by_id.insert(id, index);
5549 enclosing_breakables.stack.push(ctxt);
5553 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5554 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5555 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5556 enclosing_breakables.stack.pop().expect("missing breakable context")
5561 /// Instantiate a QueryResponse in a probe context, without a
5562 /// good ObligationCause.
5563 fn probe_instantiate_query_response(
5566 original_values: &OriginalQueryValues<'tcx>,
5567 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5568 ) -> InferResult<'tcx, Ty<'tcx>>
5570 self.instantiate_query_response_and_region_obligations(
5571 &traits::ObligationCause::misc(span, self.body_id),
5577 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5578 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5579 let mut contained_in_place = false;
5581 while let hir::Node::Expr(parent_expr) =
5582 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5584 match &parent_expr.node {
5585 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5586 if lhs.hir_id == expr_id {
5587 contained_in_place = true;
5593 expr_id = parent_expr.hir_id;
5600 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5601 generics: &ty::Generics,
5603 let own_counts = generics.own_counts();
5605 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5611 if own_counts.types == 0 {
5615 // Make a vector of booleans initially false, set to true when used.
5616 let mut types_used = vec![false; own_counts.types];
5618 for leaf_ty in ty.walk() {
5619 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5620 debug!("Found use of ty param num {}", index);
5621 types_used[index as usize - own_counts.lifetimes] = true;
5622 } else if let ty::Error = leaf_ty.sty {
5623 // If there is already another error, do not emit
5624 // an error for not using a type Parameter.
5625 assert!(tcx.sess.err_count() > 0);
5630 let types = generics.params.iter().filter(|param| match param.kind {
5631 ty::GenericParamDefKind::Type { .. } => true,
5634 for (&used, param) in types_used.iter().zip(types) {
5636 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5637 let span = tcx.hir().span_by_hir_id(id);
5638 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5639 .span_label(span, "unused type parameter")
5645 fn fatally_break_rust(sess: &Session) {
5646 let handler = sess.diagnostic();
5647 handler.span_bug_no_panic(
5649 "It looks like you're trying to break rust; would you like some ICE?",
5651 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5652 handler.note_without_error(
5653 "we would appreciate a joke overview: \
5654 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5656 handler.note_without_error(&format!("rustc {} running on {}",
5657 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5658 crate::session::config::host_triple(),
5662 fn potentially_plural_count(count: usize, word: &str) -> String {
5663 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })