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) { }
1014 /// When `check_fn` is invoked on a generator (i.e., a body that
1015 /// includes yield), it returns back some information about the yield
1017 struct GeneratorTypes<'tcx> {
1018 /// Type of value that is yielded.
1021 /// Types that are captured (see `GeneratorInterior` for more).
1024 /// Indicates if the generator is movable or static (immovable).
1025 movability: hir::GeneratorMovability,
1028 /// Helper used for fns and closures. Does the grungy work of checking a function
1029 /// body and returns the function context used for that purpose, since in the case of a fn item
1030 /// there is still a bit more to do.
1033 /// * inherited: other fields inherited from the enclosing fn (if any)
1034 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1035 param_env: ty::ParamEnv<'tcx>,
1036 fn_sig: ty::FnSig<'tcx>,
1037 decl: &'gcx hir::FnDecl,
1039 body: &'gcx hir::Body,
1040 can_be_generator: Option<hir::GeneratorMovability>)
1041 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1043 let mut fn_sig = fn_sig.clone();
1045 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1047 // Create the function context. This is either derived from scratch or,
1048 // in the case of closures, based on the outer context.
1049 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1050 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1052 let declared_ret_ty = fn_sig.output();
1053 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1054 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1055 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1056 fn_sig = fcx.tcx.mk_fn_sig(
1057 fn_sig.inputs().iter().cloned(),
1064 let span = body.value.span;
1066 if body.is_generator && can_be_generator.is_some() {
1067 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1068 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1069 fcx.yield_ty = Some(yield_ty);
1072 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1073 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1074 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1076 // Add formal parameters.
1077 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1078 // Check the pattern.
1079 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1080 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1082 // Check that argument is Sized.
1083 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1084 // for simple cases like `fn foo(x: Trait)`,
1085 // where we would error once on the parameter as a whole, and once on the binding `x`.
1086 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1087 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1090 fcx.write_ty(arg.hir_id, arg_ty);
1093 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1095 fcx.check_return_expr(&body.value);
1097 // We insert the deferred_generator_interiors entry after visiting the body.
1098 // This ensures that all nested generators appear before the entry of this generator.
1099 // resolve_generator_interiors relies on this property.
1100 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1101 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1102 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1103 Some(GeneratorTypes {
1104 yield_ty: fcx.yield_ty.unwrap(),
1106 movability: can_be_generator.unwrap(),
1112 // Finalize the return check by taking the LUB of the return types
1113 // we saw and assigning it to the expected return type. This isn't
1114 // really expected to fail, since the coercions would have failed
1115 // earlier when trying to find a LUB.
1117 // However, the behavior around `!` is sort of complex. In the
1118 // event that the `actual_return_ty` comes back as `!`, that
1119 // indicates that the fn either does not return or "returns" only
1120 // values of type `!`. In this case, if there is an expected
1121 // return type that is *not* `!`, that should be ok. But if the
1122 // return type is being inferred, we want to "fallback" to `!`:
1124 // let x = move || panic!();
1126 // To allow for that, I am creating a type variable with diverging
1127 // fallback. This was deemed ever so slightly better than unifying
1128 // the return value with `!` because it allows for the caller to
1129 // make more assumptions about the return type (e.g., they could do
1131 // let y: Option<u32> = Some(x());
1133 // which would then cause this return type to become `u32`, not
1135 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1136 let mut actual_return_ty = coercion.complete(&fcx);
1137 if actual_return_ty.is_never() {
1138 actual_return_ty = fcx.next_diverging_ty_var(
1139 TypeVariableOrigin::DivergingFn(span));
1141 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1143 // Check that the main return type implements the termination trait.
1144 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1145 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1146 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1147 if main_id == fn_id {
1148 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1149 let trait_ref = ty::TraitRef::new(term_id, substs);
1150 let return_ty_span = decl.output.span();
1151 let cause = traits::ObligationCause::new(
1152 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1154 inherited.register_predicate(
1155 traits::Obligation::new(
1156 cause, param_env, trait_ref.to_predicate()));
1161 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1162 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1163 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1164 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1165 // at this point we don't care if there are duplicate handlers or if the handler has
1166 // the wrong signature as this value we'll be used when writing metadata and that
1167 // only happens if compilation succeeded
1168 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1170 if declared_ret_ty.sty != ty::Never {
1171 fcx.tcx.sess.span_err(
1173 "return type should be `!`",
1177 let inputs = fn_sig.inputs();
1178 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1179 if inputs.len() == 1 {
1180 let arg_is_panic_info = match inputs[0].sty {
1181 ty::Ref(region, ty, mutbl) => match ty.sty {
1182 ty::Adt(ref adt, _) => {
1183 adt.did == panic_info_did &&
1184 mutbl == hir::Mutability::MutImmutable &&
1185 *region != RegionKind::ReStatic
1192 if !arg_is_panic_info {
1193 fcx.tcx.sess.span_err(
1194 decl.inputs[0].span,
1195 "argument should be `&PanicInfo`",
1199 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1200 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1201 if !generics.params.is_empty() {
1202 fcx.tcx.sess.span_err(
1204 "should have no type parameters",
1210 let span = fcx.tcx.sess.source_map().def_span(span);
1211 fcx.tcx.sess.span_err(span, "function should have one argument");
1214 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1219 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1220 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1221 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1222 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1223 if declared_ret_ty.sty != ty::Never {
1224 fcx.tcx.sess.span_err(
1226 "return type should be `!`",
1230 let inputs = fn_sig.inputs();
1231 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1232 if inputs.len() == 1 {
1233 let arg_is_alloc_layout = match inputs[0].sty {
1234 ty::Adt(ref adt, _) => {
1235 adt.did == alloc_layout_did
1240 if !arg_is_alloc_layout {
1241 fcx.tcx.sess.span_err(
1242 decl.inputs[0].span,
1243 "argument should be `Layout`",
1247 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1248 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1249 if !generics.params.is_empty() {
1250 fcx.tcx.sess.span_err(
1252 "`#[alloc_error_handler]` function should have no type \
1259 let span = fcx.tcx.sess.source_map().def_span(span);
1260 fcx.tcx.sess.span_err(span, "function should have one argument");
1263 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1271 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1274 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1275 let def = tcx.adt_def(def_id);
1276 def.destructor(tcx); // force the destructor to be evaluated
1277 check_representable(tcx, span, def_id);
1279 if def.repr.simd() {
1280 check_simd(tcx, span, def_id);
1283 check_transparent(tcx, span, def_id);
1284 check_packed(tcx, span, def_id);
1287 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1290 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1291 let def = tcx.adt_def(def_id);
1292 def.destructor(tcx); // force the destructor to be evaluated
1293 check_representable(tcx, span, def_id);
1295 check_packed(tcx, span, def_id);
1298 fn check_opaque<'a, 'tcx>(
1299 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1301 substs: SubstsRef<'tcx>,
1304 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1305 let mut err = struct_span_err!(
1306 tcx.sess, span, E0720,
1307 "opaque type expands to a recursive type",
1309 err.span_label(span, "expands to self-referential type");
1310 if let ty::Opaque(..) = partially_expanded_type.sty {
1311 err.note("type resolves to itself");
1313 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1319 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1321 "check_item_type(it.hir_id={}, it.name={})",
1323 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1325 let _indenter = indenter();
1327 // Consts can play a role in type-checking, so they are included here.
1328 hir::ItemKind::Static(..) => {
1329 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1330 tcx.typeck_tables_of(def_id);
1331 maybe_check_static_with_link_section(tcx, def_id, it.span);
1333 hir::ItemKind::Const(..) => {
1334 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1336 hir::ItemKind::Enum(ref enum_definition, _) => {
1337 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1339 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1340 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1341 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1342 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1343 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1344 check_impl_items_against_trait(
1351 let trait_def_id = impl_trait_ref.def_id;
1352 check_on_unimplemented(tcx, trait_def_id, it);
1355 hir::ItemKind::Trait(..) => {
1356 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1357 check_on_unimplemented(tcx, def_id, it);
1359 hir::ItemKind::Struct(..) => {
1360 check_struct(tcx, it.hir_id, it.span);
1362 hir::ItemKind::Union(..) => {
1363 check_union(tcx, it.hir_id, it.span);
1365 hir::ItemKind::Existential(..) => {
1366 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1368 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1369 check_opaque(tcx, def_id, substs, it.span);
1371 hir::ItemKind::Ty(..) => {
1372 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1373 let pty_ty = tcx.type_of(def_id);
1374 let generics = tcx.generics_of(def_id);
1375 check_bounds_are_used(tcx, &generics, pty_ty);
1377 hir::ItemKind::ForeignMod(ref m) => {
1378 check_abi(tcx, it.span, m.abi);
1380 if m.abi == Abi::RustIntrinsic {
1381 for item in &m.items {
1382 intrinsic::check_intrinsic_type(tcx, item);
1384 } else if m.abi == Abi::PlatformIntrinsic {
1385 for item in &m.items {
1386 intrinsic::check_platform_intrinsic_type(tcx, item);
1389 for item in &m.items {
1390 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1391 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1392 let mut err = struct_span_err!(
1396 "foreign items may not have type parameters"
1398 err.span_label(item.span, "can't have type parameters");
1399 // FIXME: once we start storing spans for type arguments, turn this into a
1402 "use specialization instead of type parameters by replacing them \
1403 with concrete types like `u32`",
1408 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1409 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1414 _ => { /* nothing to do */ }
1418 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1419 // Only restricted on wasm32 target for now
1420 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1424 // If `#[link_section]` is missing, then nothing to verify
1425 let attrs = tcx.codegen_fn_attrs(id);
1426 if attrs.link_section.is_none() {
1430 // For the wasm32 target statics with #[link_section] are placed into custom
1431 // sections of the final output file, but this isn't link custom sections of
1432 // other executable formats. Namely we can only embed a list of bytes,
1433 // nothing with pointers to anything else or relocations. If any relocation
1434 // show up, reject them here.
1435 let instance = ty::Instance::mono(tcx, id);
1436 let cid = GlobalId {
1440 let param_env = ty::ParamEnv::reveal_all();
1441 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1442 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1445 bug!("Matching on non-ByRef static")
1447 if alloc.relocations.len() != 0 {
1448 let msg = "statics with a custom `#[link_section]` must be a \
1449 simple list of bytes on the wasm target with no \
1450 extra levels of indirection such as references";
1451 tcx.sess.span_err(span, msg);
1456 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1457 trait_def_id: DefId,
1459 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1460 // an error would be reported if this fails.
1461 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1464 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1465 impl_item: &hir::ImplItem,
1468 let mut err = struct_span_err!(
1469 tcx.sess, impl_item.span, E0520,
1470 "`{}` specializes an item from a parent `impl`, but \
1471 that item is not marked `default`",
1473 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1476 match tcx.span_of_impl(parent_impl) {
1478 err.span_label(span, "parent `impl` is here");
1479 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1483 err.note(&format!("parent implementation is in crate `{}`", cname));
1490 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1491 trait_def: &ty::TraitDef,
1492 trait_item: &ty::AssocItem,
1494 impl_item: &hir::ImplItem)
1496 let ancestors = trait_def.ancestors(tcx, impl_id);
1498 let kind = match impl_item.node {
1499 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1500 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1501 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1502 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1505 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1506 .map(|node_item| node_item.map(|parent| parent.defaultness));
1508 if let Some(parent) = parent {
1509 if tcx.impl_item_is_final(&parent) {
1510 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1516 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1519 impl_trait_ref: ty::TraitRef<'tcx>,
1520 impl_item_refs: &[hir::ImplItemRef]) {
1521 let impl_span = tcx.sess.source_map().def_span(impl_span);
1523 // If the trait reference itself is erroneous (so the compilation is going
1524 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1525 // isn't populated for such impls.
1526 if impl_trait_ref.references_error() { return; }
1528 // Locate trait definition and items
1529 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1530 let mut overridden_associated_type = None;
1532 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1534 // Check existing impl methods to see if they are both present in trait
1535 // and compatible with trait signature
1536 for impl_item in impl_items() {
1537 let ty_impl_item = tcx.associated_item(
1538 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1539 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1540 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1541 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1543 // Not compatible, but needed for the error message
1544 tcx.associated_items(impl_trait_ref.def_id)
1545 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1548 // Check that impl definition matches trait definition
1549 if let Some(ty_trait_item) = ty_trait_item {
1550 match impl_item.node {
1551 hir::ImplItemKind::Const(..) => {
1552 // Find associated const definition.
1553 if ty_trait_item.kind == ty::AssocKind::Const {
1554 compare_const_impl(tcx,
1560 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1561 "item `{}` is an associated const, \
1562 which doesn't match its trait `{}`",
1565 err.span_label(impl_item.span, "does not match trait");
1566 // We can only get the spans from local trait definition
1567 // Same for E0324 and E0325
1568 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1569 err.span_label(trait_span, "item in trait");
1574 hir::ImplItemKind::Method(..) => {
1575 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1576 if ty_trait_item.kind == ty::AssocKind::Method {
1577 compare_impl_method(tcx,
1584 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1585 "item `{}` is an associated method, \
1586 which doesn't match its trait `{}`",
1589 err.span_label(impl_item.span, "does not match trait");
1590 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1591 err.span_label(trait_span, "item in trait");
1596 hir::ImplItemKind::Existential(..) |
1597 hir::ImplItemKind::Type(_) => {
1598 if ty_trait_item.kind == ty::AssocKind::Type {
1599 if ty_trait_item.defaultness.has_value() {
1600 overridden_associated_type = Some(impl_item);
1603 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1604 "item `{}` is an associated type, \
1605 which doesn't match its trait `{}`",
1608 err.span_label(impl_item.span, "does not match trait");
1609 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1610 err.span_label(trait_span, "item in trait");
1617 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1621 // Check for missing items from trait
1622 let mut missing_items = Vec::new();
1623 let mut invalidated_items = Vec::new();
1624 let associated_type_overridden = overridden_associated_type.is_some();
1625 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1626 let is_implemented = trait_def.ancestors(tcx, impl_id)
1627 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1629 .map(|node_item| !node_item.node.is_from_trait())
1632 if !is_implemented && !tcx.impl_is_default(impl_id) {
1633 if !trait_item.defaultness.has_value() {
1634 missing_items.push(trait_item);
1635 } else if associated_type_overridden {
1636 invalidated_items.push(trait_item.ident);
1641 if !missing_items.is_empty() {
1642 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1643 "not all trait items implemented, missing: `{}`",
1644 missing_items.iter()
1645 .map(|trait_item| trait_item.ident.to_string())
1646 .collect::<Vec<_>>().join("`, `"));
1647 err.span_label(impl_span, format!("missing `{}` in implementation",
1648 missing_items.iter()
1649 .map(|trait_item| trait_item.ident.to_string())
1650 .collect::<Vec<_>>().join("`, `")));
1651 for trait_item in missing_items {
1652 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1653 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1655 err.note_trait_signature(trait_item.ident.to_string(),
1656 trait_item.signature(tcx));
1662 if !invalidated_items.is_empty() {
1663 let invalidator = overridden_associated_type.unwrap();
1664 span_err!(tcx.sess, invalidator.span, E0399,
1665 "the following trait items need to be reimplemented \
1666 as `{}` was overridden: `{}`",
1668 invalidated_items.iter()
1669 .map(|name| name.to_string())
1670 .collect::<Vec<_>>().join("`, `"))
1674 /// Checks whether a type can be represented in memory. In particular, it
1675 /// identifies types that contain themselves without indirection through a
1676 /// pointer, which would mean their size is unbounded.
1677 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1681 let rty = tcx.type_of(item_def_id);
1683 // Check that it is possible to represent this type. This call identifies
1684 // (1) types that contain themselves and (2) types that contain a different
1685 // recursive type. It is only necessary to throw an error on those that
1686 // contain themselves. For case 2, there must be an inner type that will be
1687 // caught by case 1.
1688 match rty.is_representable(tcx, sp) {
1689 Representability::SelfRecursive(spans) => {
1690 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1692 err.span_label(span, "recursive without indirection");
1697 Representability::Representable | Representability::ContainsRecursive => (),
1702 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1703 let t = tcx.type_of(def_id);
1704 if let ty::Adt(def, substs) = t.sty {
1705 if def.is_struct() {
1706 let fields = &def.non_enum_variant().fields;
1707 if fields.is_empty() {
1708 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1711 let e = fields[0].ty(tcx, substs);
1712 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1713 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1714 .span_label(sp, "SIMD elements must have the same type")
1719 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1720 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1722 span_err!(tcx.sess, sp, E0077,
1723 "SIMD vector element type should be machine type");
1731 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1732 let repr = tcx.adt_def(def_id).repr;
1734 for attr in tcx.get_attrs(def_id).iter() {
1735 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1736 if let attr::ReprPacked(pack) = r {
1737 if pack != repr.pack {
1738 struct_span_err!(tcx.sess, sp, E0634,
1739 "type has conflicting packed representation hints").emit();
1745 struct_span_err!(tcx.sess, sp, E0587,
1746 "type has conflicting packed and align representation hints").emit();
1748 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1749 struct_span_err!(tcx.sess, sp, E0588,
1750 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1755 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1757 stack: &mut Vec<DefId>) -> bool {
1758 let t = tcx.type_of(def_id);
1759 if stack.contains(&def_id) {
1760 debug!("check_packed_inner: {:?} is recursive", t);
1763 if let ty::Adt(def, substs) = t.sty {
1764 if def.is_struct() || def.is_union() {
1765 if tcx.adt_def(def.did).repr.align > 0 {
1768 // push struct def_id before checking fields
1770 for field in &def.non_enum_variant().fields {
1771 let f = field.ty(tcx, substs);
1772 if let ty::Adt(def, _) = f.sty {
1773 if check_packed_inner(tcx, def.did, stack) {
1778 // only need to pop if not early out
1785 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1786 let adt = tcx.adt_def(def_id);
1787 if !adt.repr.transparent() {
1791 // For each field, figure out if it's known to be a ZST and align(1)
1792 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1793 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1794 let param_env = tcx.param_env(field.did);
1795 let layout = tcx.layout_of(param_env.and(ty));
1796 // We are currently checking the type this field came from, so it must be local
1797 let span = tcx.hir().span_if_local(field.did).unwrap();
1798 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1799 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1803 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1804 let non_zst_count = non_zst_fields.clone().count();
1805 if non_zst_count != 1 {
1806 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1807 struct_span_err!(tcx.sess, sp, E0690,
1808 "transparent struct needs exactly one non-zero-sized field, but has {}",
1810 .span_note(field_spans, "non-zero-sized field")
1813 for (span, zst, align1) in field_infos {
1815 span_err!(tcx.sess, span, E0691,
1816 "zero-sized field in transparent struct has alignment larger than 1");
1821 #[allow(trivial_numeric_casts)]
1822 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1824 vs: &'tcx [hir::Variant],
1826 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1827 let def = tcx.adt_def(def_id);
1828 def.destructor(tcx); // force the destructor to be evaluated
1831 let attributes = tcx.get_attrs(def_id);
1832 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1834 tcx.sess, attr.span, E0084,
1835 "unsupported representation for zero-variant enum")
1836 .span_label(sp, "zero-variant enum")
1841 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1842 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1843 if !tcx.features().repr128 {
1844 emit_feature_err(&tcx.sess.parse_sess,
1847 GateIssue::Language,
1848 "repr with 128-bit type is unstable");
1853 if let Some(ref e) = v.node.disr_expr {
1854 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1858 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1859 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1860 // Check for duplicate discriminant values
1861 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1862 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1863 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1864 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1865 let i_span = match variant_i.node.disr_expr {
1866 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1867 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1869 let span = match v.node.disr_expr {
1870 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1873 struct_span_err!(tcx.sess, span, E0081,
1874 "discriminant value `{}` already exists", disr_vals[i])
1875 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1876 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1879 disr_vals.push(discr);
1882 check_representable(tcx, sp, def_id);
1885 fn report_unexpected_variant_res<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1889 span_err!(tcx.sess, span, E0533,
1890 "expected unit struct/variant or constant, found {} `{}`",
1892 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1895 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1896 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1898 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1899 -> &'tcx ty::GenericPredicates<'tcx>
1902 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1903 let item_id = tcx.hir().ty_param_owner(hir_id);
1904 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1905 let generics = tcx.generics_of(item_def_id);
1906 let index = generics.param_def_id_to_index[&def_id];
1907 tcx.arena.alloc(ty::GenericPredicates {
1909 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1911 ty::Predicate::Trait(ref data)
1912 if data.skip_binder().self_ty().is_param(index) => {
1913 // HACK(eddyb) should get the original `Span`.
1914 let span = tcx.def_span(def_id);
1915 Some((predicate, span))
1923 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1924 -> Option<ty::Region<'tcx>> {
1926 Some(def) => infer::EarlyBoundRegion(span, def.name),
1927 None => infer::MiscVariable(span)
1929 Some(self.next_region_var(v))
1932 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1933 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1936 fn ty_infer_for_def(&self,
1937 ty_param_def: &ty::GenericParamDef,
1938 span: Span) -> Ty<'tcx> {
1939 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1945 fn projected_ty_from_poly_trait_ref(&self,
1948 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1951 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1953 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1957 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1960 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1961 if ty.has_escaping_bound_vars() {
1962 ty // FIXME: normalization and escaping regions
1964 self.normalize_associated_types_in(span, &ty)
1968 fn set_tainted_by_errors(&self) {
1969 self.infcx.set_tainted_by_errors()
1972 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1973 self.write_ty(hir_id, ty)
1977 /// Controls whether the arguments are tupled. This is used for the call
1980 /// Tupling means that all call-side arguments are packed into a tuple and
1981 /// passed as a single parameter. For example, if tupling is enabled, this
1984 /// fn f(x: (isize, isize))
1986 /// Can be called as:
1993 #[derive(Clone, Eq, PartialEq)]
1994 enum TupleArgumentsFlag {
1999 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2000 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2001 param_env: ty::ParamEnv<'tcx>,
2002 body_id: hir::HirId)
2003 -> FnCtxt<'a, 'gcx, 'tcx> {
2007 err_count_on_creation: inh.tcx.sess.err_count(),
2009 ret_coercion_span: RefCell::new(None),
2011 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2012 hir::CRATE_HIR_ID)),
2013 diverges: Cell::new(Diverges::Maybe),
2014 has_errors: Cell::new(false),
2015 enclosing_breakables: RefCell::new(EnclosingBreakables {
2017 by_id: Default::default(),
2023 pub fn sess(&self) -> &Session {
2027 pub fn err_count_since_creation(&self) -> usize {
2028 self.tcx.sess.err_count() - self.err_count_on_creation
2031 /// Produces warning on the given node, if the current point in the
2032 /// function is unreachable, and there hasn't been another warning.
2033 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2034 if self.diverges.get() == Diverges::Always &&
2035 // If span arose from a desugaring of `if` then it is the condition itself,
2036 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2037 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2038 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2039 self.diverges.set(Diverges::WarnedAlways);
2041 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2043 let msg = format!("unreachable {}", kind);
2044 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2050 code: ObligationCauseCode<'tcx>)
2051 -> ObligationCause<'tcx> {
2052 ObligationCause::new(span, self.body_id, code)
2055 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2056 self.cause(span, ObligationCauseCode::MiscObligation)
2059 /// Resolves type variables in `ty` if possible. Unlike the infcx
2060 /// version (resolve_vars_if_possible), this version will
2061 /// also select obligations if it seems useful, in an effort
2062 /// to get more type information.
2063 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2064 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2066 // No Infer()? Nothing needs doing.
2067 if !ty.has_infer_types() {
2068 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2072 // If `ty` is a type variable, see whether we already know what it is.
2073 ty = self.resolve_vars_if_possible(&ty);
2074 if !ty.has_infer_types() {
2075 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2079 // If not, try resolving pending obligations as much as
2080 // possible. This can help substantially when there are
2081 // indirect dependencies that don't seem worth tracking
2083 self.select_obligations_where_possible(false);
2084 ty = self.resolve_vars_if_possible(&ty);
2086 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2090 fn record_deferred_call_resolution(&self,
2091 closure_def_id: DefId,
2092 r: DeferredCallResolution<'gcx, 'tcx>) {
2093 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2094 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2097 fn remove_deferred_call_resolutions(&self,
2098 closure_def_id: DefId)
2099 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2101 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2102 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2105 pub fn tag(&self) -> String {
2106 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2107 format!("{:?}", self_ptr)
2110 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2111 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2112 span_bug!(span, "no type for local variable {}",
2113 self.tcx.hir().hir_to_string(nid))
2118 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2119 debug!("write_ty({:?}, {:?}) in fcx {}",
2120 id, self.resolve_vars_if_possible(&ty), self.tag());
2121 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2123 if ty.references_error() {
2124 self.has_errors.set(true);
2125 self.set_tainted_by_errors();
2129 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2130 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2133 pub fn write_method_call(&self,
2135 method: MethodCallee<'tcx>) {
2136 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2139 .type_dependent_defs_mut()
2140 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2142 self.write_substs(hir_id, method.substs);
2144 // When the method is confirmed, the `method.substs` includes
2145 // parameters from not just the method, but also the impl of
2146 // the method -- in particular, the `Self` type will be fully
2147 // resolved. However, those are not something that the "user
2148 // specified" -- i.e., those types come from the inferred type
2149 // of the receiver, not something the user wrote. So when we
2150 // create the user-substs, we want to replace those earlier
2151 // types with just the types that the user actually wrote --
2152 // that is, those that appear on the *method itself*.
2154 // As an example, if the user wrote something like
2155 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2156 // type of `foo` (possibly adjusted), but we don't want to
2157 // include that. We want just the `[_, u32]` part.
2158 if !method.substs.is_noop() {
2159 let method_generics = self.tcx.generics_of(method.def_id);
2160 if !method_generics.params.is_empty() {
2161 let user_type_annotation = self.infcx.probe(|_| {
2162 let user_substs = UserSubsts {
2163 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2164 let i = param.index as usize;
2165 if i < method_generics.parent_count {
2166 self.infcx.var_for_def(DUMMY_SP, param)
2171 user_self_ty: None, // not relevant here
2174 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2180 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2181 self.write_user_type_annotation(hir_id, user_type_annotation);
2186 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2187 if !substs.is_noop() {
2188 debug!("write_substs({:?}, {:?}) in fcx {}",
2193 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2197 /// Given the substs that we just converted from the HIR, try to
2198 /// canonicalize them and store them as user-given substitutions
2199 /// (i.e., substitutions that must be respected by the NLL check).
2201 /// This should be invoked **before any unifications have
2202 /// occurred**, so that annotations like `Vec<_>` are preserved
2204 pub fn write_user_type_annotation_from_substs(
2208 substs: SubstsRef<'tcx>,
2209 user_self_ty: Option<UserSelfTy<'tcx>>,
2212 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2213 user_self_ty={:?} in fcx {}",
2214 hir_id, def_id, substs, user_self_ty, self.tag(),
2217 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2218 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2219 &UserType::TypeOf(def_id, UserSubsts {
2224 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2225 self.write_user_type_annotation(hir_id, canonicalized);
2229 pub fn write_user_type_annotation(
2232 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2235 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2236 hir_id, canonical_user_type_annotation, self.tag(),
2239 if !canonical_user_type_annotation.is_identity() {
2240 self.tables.borrow_mut().user_provided_types_mut().insert(
2241 hir_id, canonical_user_type_annotation
2244 debug!("write_user_type_annotation: skipping identity substs");
2248 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2249 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2255 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2256 Entry::Vacant(entry) => { entry.insert(adj); },
2257 Entry::Occupied(mut entry) => {
2258 debug!(" - composing on top of {:?}", entry.get());
2259 match (&entry.get()[..], &adj[..]) {
2260 // Applying any adjustment on top of a NeverToAny
2261 // is a valid NeverToAny adjustment, because it can't
2263 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2265 Adjustment { kind: Adjust::Deref(_), .. },
2266 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2268 Adjustment { kind: Adjust::Deref(_), .. },
2269 .. // Any following adjustments are allowed.
2271 // A reborrow has no effect before a dereference.
2273 // FIXME: currently we never try to compose autoderefs
2274 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2276 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2277 expr, entry.get(), adj)
2279 *entry.get_mut() = adj;
2284 /// Basically whenever we are converting from a type scheme into
2285 /// the fn body space, we always want to normalize associated
2286 /// types as well. This function combines the two.
2287 fn instantiate_type_scheme<T>(&self,
2289 substs: SubstsRef<'tcx>,
2292 where T : TypeFoldable<'tcx>
2294 let value = value.subst(self.tcx, substs);
2295 let result = self.normalize_associated_types_in(span, &value);
2296 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2303 /// As `instantiate_type_scheme`, but for the bounds found in a
2304 /// generic type scheme.
2305 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2306 -> ty::InstantiatedPredicates<'tcx> {
2307 let bounds = self.tcx.predicates_of(def_id);
2308 let result = bounds.instantiate(self.tcx, substs);
2309 let result = self.normalize_associated_types_in(span, &result);
2310 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2317 /// Replaces the opaque types from the given value with type variables,
2318 /// and records the `OpaqueTypeMap` for later use during writeback. See
2319 /// `InferCtxt::instantiate_opaque_types` for more details.
2320 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2322 parent_id: hir::HirId,
2325 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2326 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2330 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2331 self.instantiate_opaque_types(
2339 let mut opaque_types = self.opaque_types.borrow_mut();
2340 for (ty, decl) in opaque_type_map {
2341 let old_value = opaque_types.insert(ty, decl);
2342 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2348 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2349 where T : TypeFoldable<'tcx>
2351 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2354 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2356 where T : TypeFoldable<'tcx>
2358 self.inh.partially_normalize_associated_types_in(span,
2364 pub fn require_type_meets(&self,
2367 code: traits::ObligationCauseCode<'tcx>,
2370 self.register_bound(
2373 traits::ObligationCause::new(span, self.body_id, code));
2376 pub fn require_type_is_sized(&self,
2379 code: traits::ObligationCauseCode<'tcx>)
2381 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2382 self.require_type_meets(ty, span, code, lang_item);
2385 pub fn require_type_is_sized_deferred(&self,
2388 code: traits::ObligationCauseCode<'tcx>)
2390 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2393 pub fn register_bound(&self,
2396 cause: traits::ObligationCause<'tcx>)
2398 self.fulfillment_cx.borrow_mut()
2399 .register_bound(self, self.param_env, ty, def_id, cause);
2402 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2403 let t = AstConv::ast_ty_to_ty(self, ast_t);
2404 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2408 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2409 let ty = self.to_ty(ast_ty);
2410 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2412 if Self::can_contain_user_lifetime_bounds(ty) {
2413 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2414 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2415 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2421 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2422 AstConv::ast_const_to_const(self, ast_c, ty)
2425 // If the type given by the user has free regions, save it for later, since
2426 // NLL would like to enforce those. Also pass in types that involve
2427 // projections, since those can resolve to `'static` bounds (modulo #54940,
2428 // which hopefully will be fixed by the time you see this comment, dear
2429 // reader, although I have my doubts). Also pass in types with inference
2430 // types, because they may be repeated. Other sorts of things are already
2431 // sufficiently enforced with erased regions. =)
2432 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2434 T: TypeFoldable<'tcx>
2436 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2439 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2440 match self.tables.borrow().node_types().get(id) {
2442 None if self.is_tainted_by_errors() => self.tcx.types.err,
2444 let node_id = self.tcx.hir().hir_to_node_id(id);
2445 bug!("no type for node {}: {} in fcx {}",
2446 node_id, self.tcx.hir().node_to_string(node_id),
2452 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2453 /// outlive the region `r`.
2454 pub fn register_wf_obligation(&self,
2457 code: traits::ObligationCauseCode<'tcx>)
2459 // WF obligations never themselves fail, so no real need to give a detailed cause:
2460 let cause = traits::ObligationCause::new(span, self.body_id, code);
2461 self.register_predicate(traits::Obligation::new(cause,
2463 ty::Predicate::WellFormed(ty)));
2466 /// Registers obligations that all types appearing in `substs` are well-formed.
2467 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2468 for ty in substs.types() {
2469 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2473 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2474 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2475 /// trait/region obligations.
2477 /// For example, if there is a function:
2480 /// fn foo<'a,T:'a>(...)
2483 /// and a reference:
2489 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2490 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2491 pub fn add_obligations_for_parameters(&self,
2492 cause: traits::ObligationCause<'tcx>,
2493 predicates: &ty::InstantiatedPredicates<'tcx>)
2495 assert!(!predicates.has_escaping_bound_vars());
2497 debug!("add_obligations_for_parameters(predicates={:?})",
2500 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2501 self.register_predicate(obligation);
2505 // FIXME(arielb1): use this instead of field.ty everywhere
2506 // Only for fields! Returns <none> for methods>
2507 // Indifferent to privacy flags
2508 pub fn field_ty(&self,
2510 field: &'tcx ty::FieldDef,
2511 substs: SubstsRef<'tcx>)
2514 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2517 fn check_casts(&self) {
2518 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2519 for cast in deferred_cast_checks.drain(..) {
2524 fn resolve_generator_interiors(&self, def_id: DefId) {
2525 let mut generators = self.deferred_generator_interiors.borrow_mut();
2526 for (body_id, interior) in generators.drain(..) {
2527 self.select_obligations_where_possible(false);
2528 generator_interior::resolve_interior(self, def_id, body_id, interior);
2532 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2533 // Non-numerics get replaced with ! or () (depending on whether
2534 // feature(never_type) is enabled, unconstrained ints with i32,
2535 // unconstrained floats with f64.
2536 // Fallback becomes very dubious if we have encountered type-checking errors.
2537 // In that case, fallback to Error.
2538 // The return value indicates whether fallback has occurred.
2539 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2540 use rustc::ty::error::UnconstrainedNumeric::Neither;
2541 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2543 assert!(ty.is_ty_infer());
2544 let fallback = match self.type_is_unconstrained_numeric(ty) {
2545 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2546 UnconstrainedInt => self.tcx.types.i32,
2547 UnconstrainedFloat => self.tcx.types.f64,
2548 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2549 Neither => return false,
2551 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2552 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2556 fn select_all_obligations_or_error(&self) {
2557 debug!("select_all_obligations_or_error");
2558 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2559 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2563 /// Select as many obligations as we can at present.
2564 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2565 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2566 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2570 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2571 /// returns a type of `&T`, but the actual type we assign to the
2572 /// *expression* is `T`. So this function just peels off the return
2573 /// type by one layer to yield `T`.
2574 fn make_overloaded_place_return_type(&self,
2575 method: MethodCallee<'tcx>)
2576 -> ty::TypeAndMut<'tcx>
2578 // extract method return type, which will be &T;
2579 let ret_ty = method.sig.output();
2581 // method returns &T, but the type as visible to user is T, so deref
2582 ret_ty.builtin_deref(true).unwrap()
2585 fn lookup_indexing(&self,
2587 base_expr: &'gcx hir::Expr,
2591 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2593 // FIXME(#18741) -- this is almost but not quite the same as the
2594 // autoderef that normal method probing does. They could likely be
2597 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2598 let mut result = None;
2599 while result.is_none() && autoderef.next().is_some() {
2600 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2602 autoderef.finalize(self);
2606 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2607 /// (and otherwise adjust) `base_expr`, looking for a type which either
2608 /// supports builtin indexing or overloaded indexing.
2609 /// This loop implements one step in that search; the autoderef loop
2610 /// is implemented by `lookup_indexing`.
2611 fn try_index_step(&self,
2613 base_expr: &hir::Expr,
2614 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2617 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2619 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2620 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2627 for &unsize in &[false, true] {
2628 let mut self_ty = adjusted_ty;
2630 // We only unsize arrays here.
2631 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2632 self_ty = self.tcx.mk_slice(element_ty);
2638 // If some lookup succeeds, write callee into table and extract index/element
2639 // type from the method signature.
2640 // If some lookup succeeded, install method in table
2641 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2642 let method = self.try_overloaded_place_op(
2643 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2645 let result = method.map(|ok| {
2646 debug!("try_index_step: success, using overloaded indexing");
2647 let method = self.register_infer_ok_obligations(ok);
2649 let mut adjustments = autoderef.adjust_steps(self, needs);
2650 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2651 let mutbl = match r_mutbl {
2652 hir::MutImmutable => AutoBorrowMutability::Immutable,
2653 hir::MutMutable => AutoBorrowMutability::Mutable {
2654 // Indexing can be desugared to a method call,
2655 // so maybe we could use two-phase here.
2656 // See the documentation of AllowTwoPhase for why that's
2657 // not the case today.
2658 allow_two_phase_borrow: AllowTwoPhase::No,
2661 adjustments.push(Adjustment {
2662 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2663 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2670 adjustments.push(Adjustment {
2671 kind: Adjust::Pointer(PointerCast::Unsize),
2672 target: method.sig.inputs()[0]
2675 self.apply_adjustments(base_expr, adjustments);
2677 self.write_method_call(expr.hir_id, method);
2678 (input_ty, self.make_overloaded_place_return_type(method).ty)
2680 if result.is_some() {
2688 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2689 let (tr, name) = match (op, is_mut) {
2690 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2691 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2692 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2693 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2695 (tr, ast::Ident::with_empty_ctxt(name))
2698 fn try_overloaded_place_op(&self,
2701 arg_tys: &[Ty<'tcx>],
2704 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2706 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2712 // Try Mut first, if needed.
2713 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2714 let method = match (needs, mut_tr) {
2715 (Needs::MutPlace, Some(trait_did)) => {
2716 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2721 // Otherwise, fall back to the immutable version.
2722 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2723 let method = match (method, imm_tr) {
2724 (None, Some(trait_did)) => {
2725 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2727 (method, _) => method,
2733 fn check_method_argument_types(&self,
2736 method: Result<MethodCallee<'tcx>, ()>,
2737 args_no_rcvr: &'gcx [hir::Expr],
2738 tuple_arguments: TupleArgumentsFlag,
2739 expected: Expectation<'tcx>)
2741 let has_error = match method {
2743 method.substs.references_error() || method.sig.references_error()
2748 let err_inputs = self.err_args(args_no_rcvr.len());
2750 let err_inputs = match tuple_arguments {
2751 DontTupleArguments => err_inputs,
2752 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2755 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2756 false, tuple_arguments, None);
2757 return self.tcx.types.err;
2760 let method = method.unwrap();
2761 // HACK(eddyb) ignore self in the definition (see above).
2762 let expected_arg_tys = self.expected_inputs_for_expected_output(
2765 method.sig.output(),
2766 &method.sig.inputs()[1..]
2768 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2769 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2770 self.tcx.hir().span_if_local(method.def_id));
2774 fn self_type_matches_expected_vid(
2776 trait_ref: ty::PolyTraitRef<'tcx>,
2777 expected_vid: ty::TyVid,
2779 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2781 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2782 trait_ref, self_ty, expected_vid
2785 ty::Infer(ty::TyVar(found_vid)) => {
2786 // FIXME: consider using `sub_root_var` here so we
2787 // can see through subtyping.
2788 let found_vid = self.root_var(found_vid);
2789 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2790 expected_vid == found_vid
2796 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2797 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2798 + Captures<'gcx> + 'b
2800 // FIXME: consider using `sub_root_var` here so we
2801 // can see through subtyping.
2802 let ty_var_root = self.root_var(self_ty);
2803 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2804 self_ty, ty_var_root,
2805 self.fulfillment_cx.borrow().pending_obligations());
2809 .pending_obligations()
2811 .filter_map(move |obligation| match obligation.predicate {
2812 ty::Predicate::Projection(ref data) =>
2813 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2814 ty::Predicate::Trait(ref data) =>
2815 Some((data.to_poly_trait_ref(), obligation)),
2816 ty::Predicate::Subtype(..) => None,
2817 ty::Predicate::RegionOutlives(..) => None,
2818 ty::Predicate::TypeOutlives(..) => None,
2819 ty::Predicate::WellFormed(..) => None,
2820 ty::Predicate::ObjectSafe(..) => None,
2821 ty::Predicate::ConstEvaluatable(..) => None,
2822 // N.B., this predicate is created by breaking down a
2823 // `ClosureType: FnFoo()` predicate, where
2824 // `ClosureType` represents some `Closure`. It can't
2825 // possibly be referring to the current closure,
2826 // because we haven't produced the `Closure` for
2827 // this closure yet; this is exactly why the other
2828 // code is looking for a self type of a unresolved
2829 // inference variable.
2830 ty::Predicate::ClosureKind(..) => None,
2831 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2834 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2835 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2836 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2840 /// Generic function that factors out common logic from function calls,
2841 /// method calls and overloaded operators.
2842 fn check_argument_types(&self,
2845 fn_inputs: &[Ty<'tcx>],
2846 expected_arg_tys: &[Ty<'tcx>],
2847 args: &'gcx [hir::Expr],
2849 tuple_arguments: TupleArgumentsFlag,
2850 def_span: Option<Span>) {
2853 // Grab the argument types, supplying fresh type variables
2854 // if the wrong number of arguments were supplied
2855 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2861 // All the input types from the fn signature must outlive the call
2862 // so as to validate implied bounds.
2863 for &fn_input_ty in fn_inputs {
2864 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2867 let expected_arg_count = fn_inputs.len();
2869 let param_count_error = |expected_count: usize,
2874 let mut err = tcx.sess.struct_span_err_with_code(sp,
2875 &format!("this function takes {}{} but {} {} supplied",
2876 if c_variadic { "at least " } else { "" },
2877 potentially_plural_count(expected_count, "parameter"),
2878 potentially_plural_count(arg_count, "parameter"),
2879 if arg_count == 1 {"was"} else {"were"}),
2880 DiagnosticId::Error(error_code.to_owned()));
2882 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2883 err.span_label(def_s, "defined here");
2886 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2887 // remove closing `)` from the span
2888 let sugg_span = sugg_span.shrink_to_lo();
2889 err.span_suggestion(
2891 "expected the unit value `()`; create it with empty parentheses",
2893 Applicability::MachineApplicable);
2895 err.span_label(sp, format!("expected {}{}",
2896 if c_variadic { "at least " } else { "" },
2897 potentially_plural_count(expected_count, "parameter")));
2902 let mut expected_arg_tys = expected_arg_tys.to_vec();
2904 let formal_tys = if tuple_arguments == TupleArguments {
2905 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2906 match tuple_type.sty {
2907 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2908 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2909 expected_arg_tys = vec![];
2910 self.err_args(args.len())
2912 ty::Tuple(arg_types) => {
2913 expected_arg_tys = match expected_arg_tys.get(0) {
2914 Some(&ty) => match ty.sty {
2915 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
2920 arg_types.iter().map(|k| k.expect_ty()).collect()
2923 span_err!(tcx.sess, sp, E0059,
2924 "cannot use call notation; the first type parameter \
2925 for the function trait is neither a tuple nor unit");
2926 expected_arg_tys = vec![];
2927 self.err_args(args.len())
2930 } else if expected_arg_count == supplied_arg_count {
2932 } else if c_variadic {
2933 if supplied_arg_count >= expected_arg_count {
2936 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2937 expected_arg_tys = vec![];
2938 self.err_args(supplied_arg_count)
2941 // is the missing argument of type `()`?
2942 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2943 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
2944 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2945 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
2949 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2951 expected_arg_tys = vec![];
2952 self.err_args(supplied_arg_count)
2955 debug!("check_argument_types: formal_tys={:?}",
2956 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2958 // If there is no expectation, expect formal_tys.
2959 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2965 // Check the arguments.
2966 // We do this in a pretty awful way: first we type-check any arguments
2967 // that are not closures, then we type-check the closures. This is so
2968 // that we have more information about the types of arguments when we
2969 // type-check the functions. This isn't really the right way to do this.
2970 for &check_closures in &[false, true] {
2971 debug!("check_closures={}", check_closures);
2973 // More awful hacks: before we check argument types, try to do
2974 // an "opportunistic" vtable resolution of any trait bounds on
2975 // the call. This helps coercions.
2977 self.select_obligations_where_possible(false);
2980 // For C-variadic functions, we don't have a declared type for all of
2981 // the arguments hence we only do our usual type checking with
2982 // the arguments who's types we do know.
2983 let t = if c_variadic {
2985 } else if tuple_arguments == TupleArguments {
2990 for (i, arg) in args.iter().take(t).enumerate() {
2991 // Warn only for the first loop (the "no closures" one).
2992 // Closure arguments themselves can't be diverging, but
2993 // a previous argument can, e.g., `foo(panic!(), || {})`.
2994 if !check_closures {
2995 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
2998 let is_closure = match arg.node {
2999 ExprKind::Closure(..) => true,
3003 if is_closure != check_closures {
3007 debug!("checking the argument");
3008 let formal_ty = formal_tys[i];
3010 // The special-cased logic below has three functions:
3011 // 1. Provide as good of an expected type as possible.
3012 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3014 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3016 // 2. Coerce to the most detailed type that could be coerced
3017 // to, which is `expected_ty` if `rvalue_hint` returns an
3018 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3019 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3020 // We're processing function arguments so we definitely want to use
3021 // two-phase borrows.
3022 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3024 // 3. Relate the expected type and the formal one,
3025 // if the expected type was used for the coercion.
3026 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3030 // We also need to make sure we at least write the ty of the other
3031 // arguments which we skipped above.
3033 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3034 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3035 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3038 for arg in args.iter().skip(expected_arg_count) {
3039 let arg_ty = self.check_expr(&arg);
3041 // There are a few types which get autopromoted when passed via varargs
3042 // in C but we just error out instead and require explicit casts.
3043 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3045 ty::Float(ast::FloatTy::F32) => {
3046 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3048 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3049 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3051 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3052 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3055 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3056 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3057 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3065 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3066 vec![self.tcx.types.err; len]
3069 // AST fragment checking
3072 expected: Expectation<'tcx>)
3078 ast::LitKind::Str(..) => tcx.mk_static_str(),
3079 ast::LitKind::ByteStr(ref v) => {
3080 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3081 tcx.mk_array(tcx.types.u8, v.len() as u64))
3083 ast::LitKind::Byte(_) => tcx.types.u8,
3084 ast::LitKind::Char(_) => tcx.types.char,
3085 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3086 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3087 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3088 let opt_ty = expected.to_option(self).and_then(|ty| {
3090 ty::Int(_) | ty::Uint(_) => Some(ty),
3091 ty::Char => Some(tcx.types.u8),
3092 ty::RawPtr(..) => Some(tcx.types.usize),
3093 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3097 opt_ty.unwrap_or_else(|| self.next_int_var())
3099 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3100 ast::LitKind::FloatUnsuffixed(_) => {
3101 let opt_ty = expected.to_option(self).and_then(|ty| {
3103 ty::Float(_) => Some(ty),
3107 opt_ty.unwrap_or_else(|| self.next_float_var())
3109 ast::LitKind::Bool(_) => tcx.types.bool,
3110 ast::LitKind::Err(_) => tcx.types.err,
3114 fn check_expr_eq_type(&self,
3115 expr: &'gcx hir::Expr,
3116 expected: Ty<'tcx>) {
3117 let ty = self.check_expr_with_hint(expr, expected);
3118 self.demand_eqtype(expr.span, expected, ty);
3121 pub fn check_expr_has_type_or_error(&self,
3122 expr: &'gcx hir::Expr,
3123 expected: Ty<'tcx>) -> Ty<'tcx> {
3124 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3127 fn check_expr_meets_expectation_or_error(&self,
3128 expr: &'gcx hir::Expr,
3129 expected: Expectation<'tcx>) -> Ty<'tcx> {
3130 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3131 let mut ty = self.check_expr_with_expectation(expr, expected);
3133 // While we don't allow *arbitrary* coercions here, we *do* allow
3134 // coercions from ! to `expected`.
3136 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3137 "expression with never type wound up being adjusted");
3138 let adj_ty = self.next_diverging_ty_var(
3139 TypeVariableOrigin::AdjustmentType(expr.span));
3140 self.apply_adjustments(expr, vec![Adjustment {
3141 kind: Adjust::NeverToAny,
3147 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3148 let expr = match &expr.node {
3149 ExprKind::DropTemps(expr) => expr,
3152 // Error possibly reported in `check_assign` so avoid emitting error again.
3153 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3158 fn check_expr_coercable_to_type(&self,
3159 expr: &'gcx hir::Expr,
3160 expected: Ty<'tcx>) -> Ty<'tcx> {
3161 let ty = self.check_expr_with_hint(expr, expected);
3162 // checks don't need two phase
3163 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3166 fn check_expr_with_hint(&self,
3167 expr: &'gcx hir::Expr,
3168 expected: Ty<'tcx>) -> Ty<'tcx> {
3169 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3172 fn check_expr_with_expectation(&self,
3173 expr: &'gcx hir::Expr,
3174 expected: Expectation<'tcx>) -> Ty<'tcx> {
3175 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3178 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3179 self.check_expr_with_expectation(expr, NoExpectation)
3182 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3183 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3186 // Determine the `Self` type, using fresh variables for all variables
3187 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3188 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3190 pub fn impl_self_ty(&self,
3191 span: Span, // (potential) receiver for this impl
3193 -> TypeAndSubsts<'tcx> {
3194 let ity = self.tcx.type_of(did);
3195 debug!("impl_self_ty: ity={:?}", ity);
3197 let substs = self.fresh_substs_for_item(span, did);
3198 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3200 TypeAndSubsts { substs: substs, ty: substd_ty }
3203 /// Unifies the output type with the expected type early, for more coercions
3204 /// and forward type information on the input expressions.
3205 fn expected_inputs_for_expected_output(&self,
3207 expected_ret: Expectation<'tcx>,
3208 formal_ret: Ty<'tcx>,
3209 formal_args: &[Ty<'tcx>])
3211 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3212 let ret_ty = match expected_ret.only_has_type(self) {
3214 None => return Vec::new()
3216 let expect_args = self.fudge_inference_if_ok(|| {
3217 // Attempt to apply a subtyping relationship between the formal
3218 // return type (likely containing type variables if the function
3219 // is polymorphic) and the expected return type.
3220 // No argument expectations are produced if unification fails.
3221 let origin = self.misc(call_span);
3222 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3224 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3225 // to identity so the resulting type is not constrained.
3228 // Process any obligations locally as much as
3229 // we can. We don't care if some things turn
3230 // out unconstrained or ambiguous, as we're
3231 // just trying to get hints here.
3232 self.save_and_restore_in_snapshot_flag(|_| {
3233 let mut fulfill = TraitEngine::new(self.tcx);
3234 for obligation in ok.obligations {
3235 fulfill.register_predicate_obligation(self, obligation);
3237 fulfill.select_where_possible(self)
3238 }).map_err(|_| ())?;
3240 Err(_) => return Err(()),
3243 // Record all the argument types, with the substitutions
3244 // produced from the above subtyping unification.
3245 Ok(formal_args.iter().map(|ty| {
3246 self.resolve_vars_if_possible(ty)
3248 }).unwrap_or_default();
3249 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3250 formal_args, formal_ret,
3251 expect_args, expected_ret);
3255 // Checks a method call.
3256 fn check_method_call(&self,
3257 expr: &'gcx hir::Expr,
3258 segment: &hir::PathSegment,
3260 args: &'gcx [hir::Expr],
3261 expected: Expectation<'tcx>,
3262 needs: Needs) -> Ty<'tcx> {
3263 let rcvr = &args[0];
3264 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3265 // no need to check for bot/err -- callee does that
3266 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3268 let method = match self.lookup_method(rcvr_t,
3274 self.write_method_call(expr.hir_id, method);
3278 if segment.ident.name != kw::Invalid {
3279 self.report_method_error(span,
3282 SelfSource::MethodCall(rcvr),
3290 // Call the generic checker.
3291 self.check_method_argument_types(span,
3299 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3303 .unwrap_or_else(|| span_bug!(return_expr.span,
3304 "check_return_expr called outside fn body"));
3306 let ret_ty = ret_coercion.borrow().expected_ty();
3307 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3308 ret_coercion.borrow_mut()
3310 &self.cause(return_expr.span,
3311 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3316 // Check field access expressions
3317 fn check_field(&self,
3318 expr: &'gcx hir::Expr,
3320 base: &'gcx hir::Expr,
3321 field: ast::Ident) -> Ty<'tcx> {
3322 let expr_t = self.check_expr_with_needs(base, needs);
3323 let expr_t = self.structurally_resolved_type(base.span,
3325 let mut private_candidate = None;
3326 let mut autoderef = self.autoderef(expr.span, expr_t);
3327 while let Some((base_t, _)) = autoderef.next() {
3329 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3330 debug!("struct named {:?}", base_t);
3331 let (ident, def_scope) =
3332 self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
3333 let fields = &base_def.non_enum_variant().fields;
3334 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3335 let field = &fields[index];
3336 let field_ty = self.field_ty(expr.span, field, substs);
3337 // Save the index of all fields regardless of their visibility in case
3338 // of error recovery.
3339 self.write_field_index(expr.hir_id, index);
3340 if field.vis.is_accessible_from(def_scope, self.tcx) {
3341 let adjustments = autoderef.adjust_steps(self, needs);
3342 self.apply_adjustments(base, adjustments);
3343 autoderef.finalize(self);
3345 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3348 private_candidate = Some((base_def.did, field_ty));
3351 ty::Tuple(ref tys) => {
3352 let fstr = field.as_str();
3353 if let Ok(index) = fstr.parse::<usize>() {
3354 if fstr == index.to_string() {
3355 if let Some(field_ty) = tys.get(index) {
3356 let adjustments = autoderef.adjust_steps(self, needs);
3357 self.apply_adjustments(base, adjustments);
3358 autoderef.finalize(self);
3360 self.write_field_index(expr.hir_id, index);
3361 return field_ty.expect_ty();
3369 autoderef.unambiguous_final_ty(self);
3371 if let Some((did, field_ty)) = private_candidate {
3372 let struct_path = self.tcx().def_path_str(did);
3373 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3374 "field `{}` of struct `{}` is private",
3375 field, struct_path);
3376 // Also check if an accessible method exists, which is often what is meant.
3377 if self.method_exists(field, expr_t, expr.hir_id, false)
3378 && !self.expr_in_place(expr.hir_id)
3380 self.suggest_method_call(
3382 &format!("a method `{}` also exists, call it with parentheses", field),
3390 } else if field.name == kw::Invalid {
3391 self.tcx().types.err
3392 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3393 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3394 "attempted to take value of method `{}` on type `{}`",
3397 if !self.expr_in_place(expr.hir_id) {
3398 self.suggest_method_call(
3400 "use parentheses to call the method",
3406 err.help("methods are immutable and cannot be assigned to");
3410 self.tcx().types.err
3412 if !expr_t.is_primitive_ty() {
3413 let mut err = self.no_such_field_err(field.span, field, expr_t);
3416 ty::Adt(def, _) if !def.is_enum() => {
3417 if let Some(suggested_field_name) =
3418 Self::suggest_field_name(def.non_enum_variant(),
3419 &field.as_str(), vec![]) {
3420 err.span_suggestion(
3422 "a field with a similar name exists",
3423 suggested_field_name.to_string(),
3424 Applicability::MaybeIncorrect,
3427 err.span_label(field.span, "unknown field");
3428 let struct_variant_def = def.non_enum_variant();
3429 let field_names = self.available_field_names(struct_variant_def);
3430 if !field_names.is_empty() {
3431 err.note(&format!("available fields are: {}",
3432 self.name_series_display(field_names)));
3436 ty::Array(_, len) => {
3437 if let (Some(len), Ok(user_index)) = (
3438 len.assert_usize(self.tcx),
3439 field.as_str().parse::<u64>()
3441 let base = self.tcx.sess.source_map()
3442 .span_to_snippet(base.span)
3444 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3445 let help = "instead of using tuple indexing, use array indexing";
3446 let suggestion = format!("{}[{}]", base, field);
3447 let applicability = if len < user_index {
3448 Applicability::MachineApplicable
3450 Applicability::MaybeIncorrect
3452 err.span_suggestion(
3453 expr.span, help, suggestion, applicability
3458 let base = self.tcx.sess.source_map()
3459 .span_to_snippet(base.span)
3460 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3461 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3462 let suggestion = format!("(*{}).{}", base, field);
3463 err.span_suggestion(
3467 Applicability::MaybeIncorrect,
3474 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3475 "`{}` is a primitive type and therefore doesn't have fields",
3478 self.tcx().types.err
3482 // Return an hint about the closest match in field names
3483 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3485 skip: Vec<LocalInternedString>)
3487 let names = variant.fields.iter().filter_map(|field| {
3488 // ignore already set fields and private fields from non-local crates
3489 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3490 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3494 Some(&field.ident.name)
3498 find_best_match_for_name(names, field, None)
3501 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3502 variant.fields.iter().filter(|field| {
3504 self.tcx.adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id).1;
3505 field.vis.is_accessible_from(def_scope, self.tcx)
3507 .map(|field| field.ident.name)
3511 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3512 // dynamic limit, to never omit just one field
3513 let limit = if names.len() == 6 { 6 } else { 5 };
3514 let mut display = names.iter().take(limit)
3515 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3516 if names.len() > limit {
3517 display = format!("{} ... and {} others", display, names.len() - limit);
3522 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3523 -> DiagnosticBuilder<'_> {
3524 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3525 "no field `{}` on type `{}`",
3529 fn report_unknown_field(
3532 variant: &'tcx ty::VariantDef,
3534 skip_fields: &[hir::Field],
3537 if variant.recovered {
3540 let mut err = self.type_error_struct_with_diag(
3542 |actual| match ty.sty {
3543 ty::Adt(adt, ..) if adt.is_enum() => {
3544 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3545 "{} `{}::{}` has no field named `{}`",
3546 kind_name, actual, variant.ident, field.ident)
3549 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3550 "{} `{}` has no field named `{}`",
3551 kind_name, actual, field.ident)
3555 // prevent all specified fields from being suggested
3556 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3557 if let Some(field_name) = Self::suggest_field_name(variant,
3558 &field.ident.as_str(),
3559 skip_fields.collect()) {
3560 err.span_suggestion(
3562 "a field with a similar name exists",
3563 field_name.to_string(),
3564 Applicability::MaybeIncorrect,
3568 ty::Adt(adt, ..) => {
3570 err.span_label(field.ident.span,
3571 format!("`{}::{}` does not have this field",
3572 ty, variant.ident));
3574 err.span_label(field.ident.span,
3575 format!("`{}` does not have this field", ty));
3577 let available_field_names = self.available_field_names(variant);
3578 if !available_field_names.is_empty() {
3579 err.note(&format!("available fields are: {}",
3580 self.name_series_display(available_field_names)));
3583 _ => bug!("non-ADT passed to report_unknown_field")
3589 fn check_expr_struct_fields(&self,
3591 expected: Expectation<'tcx>,
3592 expr_id: hir::HirId,
3594 variant: &'tcx ty::VariantDef,
3595 ast_fields: &'gcx [hir::Field],
3596 check_completeness: bool) -> bool {
3600 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3601 .get(0).cloned().unwrap_or(adt_ty);
3602 // re-link the regions that EIfEO can erase.
3603 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3605 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3606 &ty::Adt(adt, substs) => {
3607 (substs, adt.adt_kind(), adt.variant_descr())
3609 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3612 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3613 (field.ident.modern(), (i, field))
3614 ).collect::<FxHashMap<_, _>>();
3616 let mut seen_fields = FxHashMap::default();
3618 let mut error_happened = false;
3620 // Type-check each field.
3621 for field in ast_fields {
3622 let ident = tcx.adjust_ident(field.ident, variant.def_id);
3623 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3624 seen_fields.insert(ident, field.span);
3625 self.write_field_index(field.hir_id, i);
3627 // We don't look at stability attributes on
3628 // struct-like enums (yet...), but it's definitely not
3629 // a bug to have constructed one.
3630 if adt_kind != AdtKind::Enum {
3631 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3634 self.field_ty(field.span, v_field, substs)
3636 error_happened = true;
3637 if let Some(prev_span) = seen_fields.get(&ident) {
3638 let mut err = struct_span_err!(self.tcx.sess,
3641 "field `{}` specified more than once",
3644 err.span_label(field.ident.span, "used more than once");
3645 err.span_label(*prev_span, format!("first use of `{}`", ident));
3649 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3655 // Make sure to give a type to the field even if there's
3656 // an error, so we can continue type-checking.
3657 self.check_expr_coercable_to_type(&field.expr, field_type);
3660 // Make sure the programmer specified correct number of fields.
3661 if kind_name == "union" {
3662 if ast_fields.len() != 1 {
3663 tcx.sess.span_err(span, "union expressions should have exactly one field");
3665 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3666 let len = remaining_fields.len();
3668 let mut displayable_field_names = remaining_fields
3670 .map(|ident| ident.as_str())
3671 .collect::<Vec<_>>();
3673 displayable_field_names.sort();
3675 let truncated_fields_error = if len <= 3 {
3678 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3681 let remaining_fields_names = displayable_field_names.iter().take(3)
3682 .map(|n| format!("`{}`", n))
3683 .collect::<Vec<_>>()
3686 struct_span_err!(tcx.sess, span, E0063,
3687 "missing field{} {}{} in initializer of `{}`",
3688 if remaining_fields.len() == 1 { "" } else { "s" },
3689 remaining_fields_names,
3690 truncated_fields_error,
3692 .span_label(span, format!("missing {}{}",
3693 remaining_fields_names,
3694 truncated_fields_error))
3700 fn check_struct_fields_on_error(&self,
3701 fields: &'gcx [hir::Field],
3702 base_expr: &'gcx Option<P<hir::Expr>>) {
3703 for field in fields {
3704 self.check_expr(&field.expr);
3706 if let Some(ref base) = *base_expr {
3707 self.check_expr(&base);
3711 pub fn check_struct_path(&self,
3714 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3715 let path_span = match *qpath {
3716 QPath::Resolved(_, ref path) => path.span,
3717 QPath::TypeRelative(ref qself, _) => qself.span
3719 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3720 let variant = match def {
3722 self.set_tainted_by_errors();
3725 Res::Def(DefKind::Variant, _) => {
3727 ty::Adt(adt, substs) => {
3728 Some((adt.variant_of_res(def), adt.did, substs))
3730 _ => bug!("unexpected type: {:?}", ty)
3733 Res::Def(DefKind::Struct, _)
3734 | Res::Def(DefKind::Union, _)
3735 | Res::Def(DefKind::TyAlias, _)
3736 | Res::Def(DefKind::AssocTy, _)
3737 | Res::SelfTy(..) => {
3739 ty::Adt(adt, substs) if !adt.is_enum() => {
3740 Some((adt.non_enum_variant(), adt.did, substs))
3745 _ => bug!("unexpected definition: {:?}", def)
3748 if let Some((variant, did, substs)) = variant {
3749 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3750 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3752 // Check bounds on type arguments used in the path.
3753 let bounds = self.instantiate_bounds(path_span, did, substs);
3754 let cause = traits::ObligationCause::new(path_span, self.body_id,
3755 traits::ItemObligation(did));
3756 self.add_obligations_for_parameters(cause, &bounds);
3760 struct_span_err!(self.tcx.sess, path_span, E0071,
3761 "expected struct, variant or union type, found {}",
3762 ty.sort_string(self.tcx))
3763 .span_label(path_span, "not a struct")
3769 fn check_expr_struct(&self,
3771 expected: Expectation<'tcx>,
3773 fields: &'gcx [hir::Field],
3774 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3776 // Find the relevant variant
3777 let (variant, adt_ty) =
3778 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3781 self.check_struct_fields_on_error(fields, base_expr);
3782 return self.tcx.types.err;
3785 let path_span = match *qpath {
3786 QPath::Resolved(_, ref path) => path.span,
3787 QPath::TypeRelative(ref qself, _) => qself.span
3790 // Prohibit struct expressions when non-exhaustive flag is set.
3791 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3792 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3793 span_err!(self.tcx.sess, expr.span, E0639,
3794 "cannot create non-exhaustive {} using struct expression",
3795 adt.variant_descr());
3798 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3799 variant, fields, base_expr.is_none());
3800 if let &Some(ref base_expr) = base_expr {
3801 // If check_expr_struct_fields hit an error, do not attempt to populate
3802 // the fields with the base_expr. This could cause us to hit errors later
3803 // when certain fields are assumed to exist that in fact do not.
3804 if !error_happened {
3805 self.check_expr_has_type_or_error(base_expr, adt_ty);
3807 ty::Adt(adt, substs) if adt.is_struct() => {
3808 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3809 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3814 .fru_field_types_mut()
3815 .insert(expr.hir_id, fru_field_types);
3818 span_err!(self.tcx.sess, base_expr.span, E0436,
3819 "functional record update syntax requires a struct");
3824 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3830 /// If an expression has any sub-expressions that result in a type error,
3831 /// inspecting that expression's type with `ty.references_error()` will return
3832 /// true. Likewise, if an expression is known to diverge, inspecting its
3833 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3834 /// strict, _|_ can appear in the type of an expression that does not,
3835 /// itself, diverge: for example, fn() -> _|_.)
3836 /// Note that inspecting a type's structure *directly* may expose the fact
3837 /// that there are actually multiple representations for `Error`, so avoid
3838 /// that when err needs to be handled differently.
3839 fn check_expr_with_expectation_and_needs(&self,
3840 expr: &'gcx hir::Expr,
3841 expected: Expectation<'tcx>,
3842 needs: Needs) -> Ty<'tcx> {
3843 debug!(">> type-checking: expr={:?} expected={:?}",
3846 // Warn for expressions after diverging siblings.
3847 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3849 // Hide the outer diverging and has_errors flags.
3850 let old_diverges = self.diverges.get();
3851 let old_has_errors = self.has_errors.get();
3852 self.diverges.set(Diverges::Maybe);
3853 self.has_errors.set(false);
3855 let ty = self.check_expr_kind(expr, expected, needs);
3857 // Warn for non-block expressions with diverging children.
3859 ExprKind::Block(..) |
3860 ExprKind::Loop(..) | ExprKind::While(..) |
3861 ExprKind::Match(..) => {}
3863 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3866 // Any expression that produces a value of type `!` must have diverged
3868 self.diverges.set(self.diverges.get() | Diverges::Always);
3871 // Record the type, which applies it effects.
3872 // We need to do this after the warning above, so that
3873 // we don't warn for the diverging expression itself.
3874 self.write_ty(expr.hir_id, ty);
3876 // Combine the diverging and has_error flags.
3877 self.diverges.set(self.diverges.get() | old_diverges);
3878 self.has_errors.set(self.has_errors.get() | old_has_errors);
3880 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3881 debug!("... {:?}, expected is {:?}", ty, expected);
3888 expr: &'gcx hir::Expr,
3889 expected: Expectation<'tcx>,
3893 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3900 let id = expr.hir_id;
3902 ExprKind::Box(ref subexpr) => {
3903 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3905 ty::Adt(def, _) if def.is_box()
3906 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3910 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3911 tcx.mk_box(referent_ty)
3914 ExprKind::Lit(ref lit) => {
3915 self.check_lit(&lit, expected)
3917 ExprKind::Binary(op, ref lhs, ref rhs) => {
3918 self.check_binop(expr, op, lhs, rhs)
3920 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3921 self.check_binop_assign(expr, op, lhs, rhs)
3923 ExprKind::Unary(unop, ref oprnd) => {
3924 let expected_inner = match unop {
3925 hir::UnNot | hir::UnNeg => {
3932 let needs = match unop {
3933 hir::UnDeref => needs,
3936 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3940 if !oprnd_t.references_error() {
3941 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3944 if let Some(mt) = oprnd_t.builtin_deref(true) {
3946 } else if let Some(ok) = self.try_overloaded_deref(
3947 expr.span, oprnd_t, needs) {
3948 let method = self.register_infer_ok_obligations(ok);
3949 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3950 let mutbl = match mutbl {
3951 hir::MutImmutable => AutoBorrowMutability::Immutable,
3952 hir::MutMutable => AutoBorrowMutability::Mutable {
3953 // (It shouldn't actually matter for unary ops whether
3954 // we enable two-phase borrows or not, since a unary
3955 // op has no additional operands.)
3956 allow_two_phase_borrow: AllowTwoPhase::No,
3959 self.apply_adjustments(oprnd, vec![Adjustment {
3960 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3961 target: method.sig.inputs()[0]
3964 oprnd_t = self.make_overloaded_place_return_type(method).ty;
3965 self.write_method_call(expr.hir_id, method);
3967 let mut err = type_error_struct!(
3972 "type `{}` cannot be dereferenced",
3975 let sp = tcx.sess.source_map().start_point(expr.span);
3976 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
3979 tcx.sess.parse_sess.expr_parentheses_needed(
3986 oprnd_t = tcx.types.err;
3990 let result = self.check_user_unop(expr, oprnd_t, unop);
3991 // If it's builtin, we can reuse the type, this helps inference.
3992 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
3997 let result = self.check_user_unop(expr, oprnd_t, unop);
3998 // If it's builtin, we can reuse the type, this helps inference.
3999 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4007 ExprKind::AddrOf(mutbl, ref oprnd) => {
4008 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4010 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4011 if oprnd.is_place_expr() {
4012 // Places may legitimately have unsized types.
4013 // For example, dereferences of a fat pointer and
4014 // the last field of a struct can be unsized.
4017 Expectation::rvalue_hint(self, ty)
4023 let needs = Needs::maybe_mut_place(mutbl);
4024 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4026 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4027 if tm.ty.references_error() {
4030 // Note: at this point, we cannot say what the best lifetime
4031 // is to use for resulting pointer. We want to use the
4032 // shortest lifetime possible so as to avoid spurious borrowck
4033 // errors. Moreover, the longest lifetime will depend on the
4034 // precise details of the value whose address is being taken
4035 // (and how long it is valid), which we don't know yet until type
4036 // inference is complete.
4038 // Therefore, here we simply generate a region variable. The
4039 // region inferencer will then select the ultimate value.
4040 // Finally, borrowck is charged with guaranteeing that the
4041 // value whose address was taken can actually be made to live
4042 // as long as it needs to live.
4043 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4044 tcx.mk_ref(region, tm)
4047 ExprKind::Path(ref qpath) => {
4048 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4050 let ty = match res {
4052 self.set_tainted_by_errors();
4055 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4056 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4059 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4062 if let ty::FnDef(..) = ty.sty {
4063 let fn_sig = ty.fn_sig(tcx);
4064 if !tcx.features().unsized_locals {
4065 // We want to remove some Sized bounds from std functions,
4066 // but don't want to expose the removal to stable Rust.
4067 // i.e., we don't want to allow
4073 // to work in stable even if the Sized bound on `drop` is relaxed.
4074 for i in 0..fn_sig.inputs().skip_binder().len() {
4075 // We just want to check sizedness, so instead of introducing
4076 // placeholder lifetimes with probing, we just replace higher lifetimes
4078 let input = self.replace_bound_vars_with_fresh_vars(
4080 infer::LateBoundRegionConversionTime::FnCall,
4081 &fn_sig.input(i)).0;
4082 self.require_type_is_sized_deferred(input, expr.span,
4083 traits::SizedArgumentType);
4086 // Here we want to prevent struct constructors from returning unsized types.
4087 // There were two cases this happened: fn pointer coercion in stable
4088 // and usual function call in presense of unsized_locals.
4089 // Also, as we just want to check sizedness, instead of introducing
4090 // placeholder lifetimes with probing, we just replace higher lifetimes
4092 let output = self.replace_bound_vars_with_fresh_vars(
4094 infer::LateBoundRegionConversionTime::FnCall,
4095 &fn_sig.output()).0;
4096 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4099 // We always require that the type provided as the value for
4100 // a type parameter outlives the moment of instantiation.
4101 let substs = self.tables.borrow().node_substs(expr.hir_id);
4102 self.add_wf_bounds(substs, expr);
4106 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4107 for expr in outputs.iter().chain(inputs.iter()) {
4108 self.check_expr(expr);
4112 ExprKind::Break(destination, ref expr_opt) => {
4113 if let Ok(target_id) = destination.target_id {
4115 if let Some(ref e) = *expr_opt {
4116 // If this is a break with a value, we need to type-check
4117 // the expression. Get an expected type from the loop context.
4118 let opt_coerce_to = {
4119 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4120 enclosing_breakables.find_breakable(target_id)
4123 .map(|coerce| coerce.expected_ty())
4126 // If the loop context is not a `loop { }`, then break with
4127 // a value is illegal, and `opt_coerce_to` will be `None`.
4128 // Just set expectation to error in that case.
4129 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4131 // Recurse without `enclosing_breakables` borrowed.
4132 e_ty = self.check_expr_with_hint(e, coerce_to);
4133 cause = self.misc(e.span);
4135 // Otherwise, this is a break *without* a value. That's
4136 // always legal, and is equivalent to `break ()`.
4137 e_ty = tcx.mk_unit();
4138 cause = self.misc(expr.span);
4141 // Now that we have type-checked `expr_opt`, borrow
4142 // the `enclosing_loops` field and let's coerce the
4143 // type of `expr_opt` into what is expected.
4144 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4145 let ctxt = enclosing_breakables.find_breakable(target_id);
4146 if let Some(ref mut coerce) = ctxt.coerce {
4147 if let Some(ref e) = *expr_opt {
4148 coerce.coerce(self, &cause, e, e_ty);
4150 assert!(e_ty.is_unit());
4151 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4154 // If `ctxt.coerce` is `None`, we can just ignore
4155 // the type of the expresison. This is because
4156 // either this was a break *without* a value, in
4157 // which case it is always a legal type (`()`), or
4158 // else an error would have been flagged by the
4159 // `loops` pass for using break with an expression
4160 // where you are not supposed to.
4161 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4164 ctxt.may_break = true;
4166 // the type of a `break` is always `!`, since it diverges
4169 // Otherwise, we failed to find the enclosing loop;
4170 // this can only happen if the `break` was not
4171 // inside a loop at all, which is caught by the
4172 // loop-checking pass.
4173 if self.tcx.sess.err_count() == 0 {
4174 self.tcx.sess.delay_span_bug(expr.span,
4175 "break was outside loop, but no error was emitted");
4178 // We still need to assign a type to the inner expression to
4179 // prevent the ICE in #43162.
4180 if let Some(ref e) = *expr_opt {
4181 self.check_expr_with_hint(e, tcx.types.err);
4183 // ... except when we try to 'break rust;'.
4184 // ICE this expression in particular (see #43162).
4185 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4186 if path.segments.len() == 1 &&
4187 path.segments[0].ident.name == sym::rust {
4188 fatally_break_rust(self.tcx.sess);
4192 // There was an error; make type-check fail.
4197 ExprKind::Continue(destination) => {
4198 if destination.target_id.is_ok() {
4201 // There was an error; make type-check fail.
4205 ExprKind::Ret(ref expr_opt) => {
4206 if self.ret_coercion.is_none() {
4207 struct_span_err!(self.tcx.sess, expr.span, E0572,
4208 "return statement outside of function body").emit();
4209 } else if let Some(ref e) = *expr_opt {
4210 if self.ret_coercion_span.borrow().is_none() {
4211 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4213 self.check_return_expr(e);
4215 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4216 if self.ret_coercion_span.borrow().is_none() {
4217 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4219 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4220 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4221 coercion.coerce_forced_unit(
4226 fn_decl.output.span(),
4228 "expected `{}` because of this return type",
4236 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4241 ExprKind::Assign(ref lhs, ref rhs) => {
4242 self.check_assign(expr, expected, lhs, rhs)
4244 ExprKind::While(ref cond, ref body, _) => {
4245 let ctxt = BreakableCtxt {
4246 // cannot use break with a value from a while loop
4248 may_break: false, // Will get updated if/when we find a `break`.
4251 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4252 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4253 let cond_diverging = self.diverges.get();
4254 self.check_block_no_value(&body);
4256 // We may never reach the body so it diverging means nothing.
4257 self.diverges.set(cond_diverging);
4261 // No way to know whether it's diverging because
4262 // of a `break` or an outer `break` or `return`.
4263 self.diverges.set(Diverges::Maybe);
4268 ExprKind::Loop(ref body, _, source) => {
4269 let coerce = match source {
4270 // you can only use break with a value from a normal `loop { }`
4271 hir::LoopSource::Loop => {
4272 let coerce_to = expected.coercion_target_type(self, body.span);
4273 Some(CoerceMany::new(coerce_to))
4276 hir::LoopSource::WhileLet |
4277 hir::LoopSource::ForLoop => {
4282 let ctxt = BreakableCtxt {
4284 may_break: false, // Will get updated if/when we find a `break`.
4287 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4288 self.check_block_no_value(&body);
4292 // No way to know whether it's diverging because
4293 // of a `break` or an outer `break` or `return`.
4294 self.diverges.set(Diverges::Maybe);
4297 // If we permit break with a value, then result type is
4298 // the LUB of the breaks (possibly ! if none); else, it
4299 // is nil. This makes sense because infinite loops
4300 // (which would have type !) are only possible iff we
4301 // permit break with a value [1].
4302 if ctxt.coerce.is_none() && !ctxt.may_break {
4304 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4306 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4308 ExprKind::Match(ref discrim, ref arms, match_src) => {
4309 self.check_match(expr, &discrim, arms, expected, match_src)
4311 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4312 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4314 ExprKind::Block(ref body, _) => {
4315 self.check_block_with_expected(&body, expected)
4317 ExprKind::Call(ref callee, ref args) => {
4318 self.check_call(expr, &callee, args, expected)
4320 ExprKind::MethodCall(ref segment, span, ref args) => {
4321 self.check_method_call(expr, segment, span, args, expected, needs)
4323 ExprKind::Cast(ref e, ref t) => {
4324 // Find the type of `e`. Supply hints based on the type we are casting to,
4326 let t_cast = self.to_ty_saving_user_provided_ty(t);
4327 let t_cast = self.resolve_vars_if_possible(&t_cast);
4328 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4329 let t_cast = self.resolve_vars_if_possible(&t_cast);
4331 // Eagerly check for some obvious errors.
4332 if t_expr.references_error() || t_cast.references_error() {
4335 // Defer other checks until we're done type checking.
4336 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4337 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4339 deferred_cast_checks.push(cast_check);
4342 Err(ErrorReported) => {
4348 ExprKind::Type(ref e, ref t) => {
4349 let ty = self.to_ty_saving_user_provided_ty(&t);
4350 self.check_expr_eq_type(&e, ty);
4353 ExprKind::DropTemps(ref e) => {
4354 self.check_expr_with_expectation(e, expected)
4356 ExprKind::Array(ref args) => {
4357 let uty = expected.to_option(self).and_then(|uty| {
4359 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4364 let element_ty = if !args.is_empty() {
4365 let coerce_to = uty.unwrap_or_else(
4366 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4367 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4368 assert_eq!(self.diverges.get(), Diverges::Maybe);
4370 let e_ty = self.check_expr_with_hint(e, coerce_to);
4371 let cause = self.misc(e.span);
4372 coerce.coerce(self, &cause, e, e_ty);
4374 coerce.complete(self)
4376 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4378 tcx.mk_array(element_ty, args.len() as u64)
4380 ExprKind::Repeat(ref element, ref count) => {
4381 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4382 let param_env = ty::ParamEnv::empty();
4383 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4384 let instance = ty::Instance::resolve(
4390 let global_id = GlobalId {
4394 let count = tcx.const_eval(param_env.and(global_id));
4396 let uty = match expected {
4397 ExpectHasType(uty) => {
4399 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4406 let (element_ty, t) = match uty {
4408 self.check_expr_coercable_to_type(&element, uty);
4412 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4413 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4418 if let Ok(count) = count {
4419 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4421 // For [foo, ..n] where n > 1, `foo` must have
4423 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4424 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4428 if element_ty.references_error() {
4430 } else if let Ok(count) = count {
4431 tcx.mk_ty(ty::Array(t, count))
4436 ExprKind::Tup(ref elts) => {
4437 let flds = expected.only_has_type(self).and_then(|ty| {
4438 let ty = self.resolve_type_vars_with_obligations(ty);
4440 ty::Tuple(ref flds) => Some(&flds[..]),
4445 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4446 let t = match flds {
4447 Some(ref fs) if i < fs.len() => {
4448 let ety = fs[i].expect_ty();
4449 self.check_expr_coercable_to_type(&e, ety);
4453 self.check_expr_with_expectation(&e, NoExpectation)
4458 let tuple = tcx.mk_tup(elt_ts_iter);
4459 if tuple.references_error() {
4462 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4466 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4467 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4469 ExprKind::Field(ref base, field) => {
4470 self.check_field(expr, needs, &base, field)
4472 ExprKind::Index(ref base, ref idx) => {
4473 let base_t = self.check_expr_with_needs(&base, needs);
4474 let idx_t = self.check_expr(&idx);
4476 if base_t.references_error() {
4478 } else if idx_t.references_error() {
4481 let base_t = self.structurally_resolved_type(base.span, base_t);
4482 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4483 Some((index_ty, element_ty)) => {
4484 // two-phase not needed because index_ty is never mutable
4485 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4490 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4491 "cannot index into a value of type `{}`",
4493 // Try to give some advice about indexing tuples.
4494 if let ty::Tuple(..) = base_t.sty {
4495 let mut needs_note = true;
4496 // If the index is an integer, we can show the actual
4497 // fixed expression:
4498 if let ExprKind::Lit(ref lit) = idx.node {
4499 if let ast::LitKind::Int(i,
4500 ast::LitIntType::Unsuffixed) = lit.node {
4501 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4502 if let Ok(snip) = snip {
4503 err.span_suggestion(
4505 "to access tuple elements, use",
4506 format!("{}.{}", snip, i),
4507 Applicability::MachineApplicable,
4514 err.help("to access tuple elements, use tuple indexing \
4515 syntax (e.g., `tuple.0`)");
4524 ExprKind::Yield(ref value) => {
4525 match self.yield_ty {
4527 self.check_expr_coercable_to_type(&value, ty);
4530 struct_span_err!(self.tcx.sess, expr.span, E0627,
4531 "yield statement outside of generator literal").emit();
4536 hir::ExprKind::Err => {
4542 /// Type check assignment expression `expr` of form `lhs = rhs`.
4543 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4546 expr: &'gcx hir::Expr,
4547 expected: Expectation<'tcx>,
4548 lhs: &'gcx hir::Expr,
4549 rhs: &'gcx hir::Expr,
4551 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4552 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4554 let expected_ty = expected.coercion_target_type(self, expr.span);
4555 if expected_ty == self.tcx.types.bool {
4556 // The expected type is `bool` but this will result in `()` so we can reasonably
4557 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4558 // The likely cause of this is `if foo = bar { .. }`.
4559 let actual_ty = self.tcx.mk_unit();
4560 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4561 let msg = "try comparing for equality";
4562 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4563 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4564 if let (Ok(left), Ok(right)) = (left, right) {
4565 let help = format!("{} == {}", left, right);
4566 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4571 } else if !lhs.is_place_expr() {
4572 struct_span_err!(self.tcx.sess, expr.span, E0070,
4573 "invalid left-hand side expression")
4574 .span_label(expr.span, "left-hand of expression not valid")
4578 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4580 if lhs_ty.references_error() || rhs_ty.references_error() {
4587 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4588 // The newly resolved definition is written into `type_dependent_defs`.
4589 fn finish_resolving_struct_path(&self,
4596 QPath::Resolved(ref maybe_qself, ref path) => {
4597 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4598 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4601 QPath::TypeRelative(ref qself, ref segment) => {
4602 let ty = self.to_ty(qself);
4604 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4609 let result = AstConv::associated_path_to_ty(
4618 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4619 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4621 // Write back the new resolution.
4622 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4624 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4629 /// Resolves associated value path into a base type and associated constant or method
4630 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4631 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4635 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4637 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4638 let (ty, qself, item_segment) = match *qpath {
4639 QPath::Resolved(ref opt_qself, ref path) => {
4641 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4642 &path.segments[..]);
4644 QPath::TypeRelative(ref qself, ref segment) => {
4645 (self.to_ty(qself), qself, segment)
4648 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4649 // Return directly on cache hit. This is useful to avoid doubly reporting
4650 // errors with default match binding modes. See #44614.
4651 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4652 .unwrap_or(Res::Err);
4653 return (def, Some(ty), slice::from_ref(&**item_segment));
4655 let item_name = item_segment.ident;
4656 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4657 let result = match error {
4658 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4659 _ => Err(ErrorReported),
4661 if item_name.name != kw::Invalid {
4662 self.report_method_error(
4666 SelfSource::QPath(qself),
4674 // Write back the new resolution.
4675 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4677 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4679 slice::from_ref(&**item_segment),
4683 pub fn check_decl_initializer(&self,
4684 local: &'gcx hir::Local,
4685 init: &'gcx hir::Expr) -> Ty<'tcx>
4687 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4688 // for #42640 (default match binding modes).
4691 let ref_bindings = local.pat.contains_explicit_ref_binding();
4693 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4694 if let Some(m) = ref_bindings {
4695 // Somewhat subtle: if we have a `ref` binding in the pattern,
4696 // we want to avoid introducing coercions for the RHS. This is
4697 // both because it helps preserve sanity and, in the case of
4698 // ref mut, for soundness (issue #23116). In particular, in
4699 // the latter case, we need to be clear that the type of the
4700 // referent for the reference that results is *equal to* the
4701 // type of the place it is referencing, and not some
4702 // supertype thereof.
4703 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4704 self.demand_eqtype(init.span, local_ty, init_ty);
4707 self.check_expr_coercable_to_type(init, local_ty)
4711 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4712 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4713 self.write_ty(local.hir_id, t);
4715 if let Some(ref init) = local.init {
4716 let init_ty = self.check_decl_initializer(local, &init);
4717 if init_ty.references_error() {
4718 self.write_ty(local.hir_id, init_ty);
4722 self.check_pat_walk(
4725 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4728 let pat_ty = self.node_ty(local.pat.hir_id);
4729 if pat_ty.references_error() {
4730 self.write_ty(local.hir_id, pat_ty);
4734 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4735 // Don't do all the complex logic below for `DeclItem`.
4737 hir::StmtKind::Item(..) => return,
4738 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4741 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4743 // Hide the outer diverging and `has_errors` flags.
4744 let old_diverges = self.diverges.get();
4745 let old_has_errors = self.has_errors.get();
4746 self.diverges.set(Diverges::Maybe);
4747 self.has_errors.set(false);
4750 hir::StmtKind::Local(ref l) => {
4751 self.check_decl_local(&l);
4754 hir::StmtKind::Item(_) => {}
4755 hir::StmtKind::Expr(ref expr) => {
4756 // Check with expected type of `()`.
4757 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4759 hir::StmtKind::Semi(ref expr) => {
4760 self.check_expr(&expr);
4764 // Combine the diverging and `has_error` flags.
4765 self.diverges.set(self.diverges.get() | old_diverges);
4766 self.has_errors.set(self.has_errors.get() | old_has_errors);
4769 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4770 let unit = self.tcx.mk_unit();
4771 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4773 // if the block produces a `!` value, that can always be
4774 // (effectively) coerced to unit.
4776 self.demand_suptype(blk.span, unit, ty);
4780 fn check_block_with_expected(&self,
4781 blk: &'gcx hir::Block,
4782 expected: Expectation<'tcx>) -> Ty<'tcx> {
4784 let mut fcx_ps = self.ps.borrow_mut();
4785 let unsafety_state = fcx_ps.recurse(blk);
4786 replace(&mut *fcx_ps, unsafety_state)
4789 // In some cases, blocks have just one exit, but other blocks
4790 // can be targeted by multiple breaks. This can happen both
4791 // with labeled blocks as well as when we desugar
4792 // a `try { ... }` expression.
4796 // 'a: { if true { break 'a Err(()); } Ok(()) }
4798 // Here we would wind up with two coercions, one from
4799 // `Err(())` and the other from the tail expression
4800 // `Ok(())`. If the tail expression is omitted, that's a
4801 // "forced unit" -- unless the block diverges, in which
4802 // case we can ignore the tail expression (e.g., `'a: {
4803 // break 'a 22; }` would not force the type of the block
4805 let tail_expr = blk.expr.as_ref();
4806 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4807 let coerce = if blk.targeted_by_break {
4808 CoerceMany::new(coerce_to_ty)
4810 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4811 Some(e) => slice::from_ref(e),
4814 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4817 let prev_diverges = self.diverges.get();
4818 let ctxt = BreakableCtxt {
4819 coerce: Some(coerce),
4823 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4824 for s in &blk.stmts {
4828 // check the tail expression **without** holding the
4829 // `enclosing_breakables` lock below.
4830 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4832 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4833 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4834 let coerce = ctxt.coerce.as_mut().unwrap();
4835 if let Some(tail_expr_ty) = tail_expr_ty {
4836 let tail_expr = tail_expr.unwrap();
4837 let cause = self.cause(tail_expr.span,
4838 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4844 // Subtle: if there is no explicit tail expression,
4845 // that is typically equivalent to a tail expression
4846 // of `()` -- except if the block diverges. In that
4847 // case, there is no value supplied from the tail
4848 // expression (assuming there are no other breaks,
4849 // this implies that the type of the block will be
4852 // #41425 -- label the implicit `()` as being the
4853 // "found type" here, rather than the "expected type".
4854 if !self.diverges.get().always() {
4855 // #50009 -- Do not point at the entire fn block span, point at the return type
4856 // span, as it is the cause of the requirement, and
4857 // `consider_hint_about_removing_semicolon` will point at the last expression
4858 // if it were a relevant part of the error. This improves usability in editors
4859 // that highlight errors inline.
4860 let mut sp = blk.span;
4861 let mut fn_span = None;
4862 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4863 let ret_sp = decl.output.span();
4864 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4865 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4866 // output would otherwise be incorrect and even misleading. Make sure
4867 // the span we're aiming at correspond to a `fn` body.
4868 if block_sp == blk.span {
4870 fn_span = Some(ident.span);
4874 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4875 if let Some(expected_ty) = expected.only_has_type(self) {
4876 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4878 if let Some(fn_span) = fn_span {
4879 err.span_label(fn_span, "this function's body doesn't return");
4887 // If we can break from the block, then the block's exit is always reachable
4888 // (... as long as the entry is reachable) - regardless of the tail of the block.
4889 self.diverges.set(prev_diverges);
4892 let mut ty = ctxt.coerce.unwrap().complete(self);
4894 if self.has_errors.get() || ty.references_error() {
4895 ty = self.tcx.types.err
4898 self.write_ty(blk.hir_id, ty);
4900 *self.ps.borrow_mut() = prev;
4904 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4905 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4907 Node::Item(&hir::Item {
4908 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4910 Node::ImplItem(&hir::ImplItem {
4911 node: hir::ImplItemKind::Method(_, body_id), ..
4913 let body = self.tcx.hir().body(body_id);
4914 if let ExprKind::Block(block, _) = &body.value.node {
4915 return Some(block.span);
4923 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4924 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4925 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4926 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4929 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4930 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4932 Node::Item(&hir::Item {
4933 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4934 }) => decl.clone().and_then(|decl| {
4935 // This is less than ideal, it will not suggest a return type span on any
4936 // method called `main`, regardless of whether it is actually the entry point,
4937 // but it will still present it as the reason for the expected type.
4938 Some((decl, ident, ident.name != sym::main))
4940 Node::TraitItem(&hir::TraitItem {
4941 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4944 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
4945 Node::ImplItem(&hir::ImplItem {
4946 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4949 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
4954 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4955 /// suggestion can be made, `None` otherwise.
4956 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
4957 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4958 // `while` before reaching it, as block tail returns are not available in them.
4959 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4960 let parent = self.tcx.hir().get_by_hir_id(blk_id);
4961 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4965 /// On implicit return expressions with mismatched types, provides the following suggestions:
4967 /// - Points out the method's return type as the reason for the expected type.
4968 /// - Possible missing semicolon.
4969 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4970 pub fn suggest_mismatched_types_on_tail(
4972 err: &mut DiagnosticBuilder<'tcx>,
4973 expression: &'gcx hir::Expr,
4979 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4980 let mut pointing_at_return_type = false;
4981 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4982 pointing_at_return_type = self.suggest_missing_return_type(
4983 err, &fn_decl, expected, found, can_suggest);
4985 self.suggest_ref_or_into(err, expression, expected, found);
4986 pointing_at_return_type
4989 pub fn suggest_ref_or_into(
4991 err: &mut DiagnosticBuilder<'tcx>,
4996 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4997 err.span_suggestion(
5001 Applicability::MachineApplicable,
5003 } else if !self.check_for_cast(err, expr, found, expected) {
5004 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5008 let methods = self.get_conversion_methods(expr.span, expected, found);
5009 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5010 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5011 .filter_map(|(receiver, method)| {
5012 let method_call = format!(".{}()", method.ident);
5013 if receiver.ends_with(&method_call) {
5014 None // do not suggest code that is already there (#53348)
5016 let method_call_list = [".to_vec()", ".to_string()"];
5017 let sugg = if receiver.ends_with(".clone()")
5018 && method_call_list.contains(&method_call.as_str()) {
5019 let max_len = receiver.rfind(".").unwrap();
5020 format!("{}{}", &receiver[..max_len], method_call)
5022 format!("{}{}", receiver, method_call)
5024 Some(if is_struct_pat_shorthand_field {
5025 format!("{}: {}", receiver, sugg)
5031 if suggestions.peek().is_some() {
5032 err.span_suggestions(
5034 "try using a conversion method",
5036 Applicability::MaybeIncorrect,
5043 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5047 /// bar_that_returns_u32()
5051 /// This routine checks if the return expression in a block would make sense on its own as a
5052 /// statement and the return type has been left as default or has been specified as `()`. If so,
5053 /// it suggests adding a semicolon.
5054 fn suggest_missing_semicolon(&self,
5055 err: &mut DiagnosticBuilder<'tcx>,
5056 expression: &'gcx hir::Expr,
5059 if expected.is_unit() {
5060 // `BlockTailExpression` only relevant if the tail expr would be
5061 // useful on its own.
5062 match expression.node {
5063 ExprKind::Call(..) |
5064 ExprKind::MethodCall(..) |
5065 ExprKind::While(..) |
5066 ExprKind::Loop(..) |
5067 ExprKind::Match(..) |
5068 ExprKind::Block(..) => {
5069 let sp = self.tcx.sess.source_map().next_point(cause_span);
5070 err.span_suggestion(
5072 "try adding a semicolon",
5074 Applicability::MachineApplicable);
5081 /// A possible error is to forget to add a return type that is needed:
5085 /// bar_that_returns_u32()
5089 /// This routine checks if the return type is left as default, the method is not part of an
5090 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5092 fn suggest_missing_return_type(
5094 err: &mut DiagnosticBuilder<'tcx>,
5095 fn_decl: &hir::FnDecl,
5100 // Only suggest changing the return type for methods that
5101 // haven't set a return type at all (and aren't `fn main()` or an impl).
5102 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5103 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5104 err.span_suggestion(
5106 "try adding a return type",
5107 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5108 Applicability::MachineApplicable);
5111 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5112 err.span_label(span, "possibly return type missing here?");
5115 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5116 // `fn main()` must return `()`, do not suggest changing return type
5117 err.span_label(span, "expected `()` because of default return type");
5120 // expectation was caused by something else, not the default return
5121 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5122 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5123 // Only point to return type if the expected type is the return type, as if they
5124 // are not, the expectation must have been caused by something else.
5125 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5127 let ty = AstConv::ast_ty_to_ty(self, ty);
5128 debug!("suggest_missing_return_type: return type {:?}", ty);
5129 debug!("suggest_missing_return_type: expected type {:?}", ty);
5130 if ty.sty == expected.sty {
5131 err.span_label(sp, format!("expected `{}` because of return type",
5140 /// A common error is to add an extra semicolon:
5143 /// fn foo() -> usize {
5148 /// This routine checks if the final statement in a block is an
5149 /// expression with an explicit semicolon whose type is compatible
5150 /// with `expected_ty`. If so, it suggests removing the semicolon.
5151 fn consider_hint_about_removing_semicolon(
5153 blk: &'gcx hir::Block,
5154 expected_ty: Ty<'tcx>,
5155 err: &mut DiagnosticBuilder<'_>,
5157 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5158 err.span_suggestion(
5160 "consider removing this semicolon",
5162 Applicability::MachineApplicable,
5167 fn could_remove_semicolon(
5169 blk: &'gcx hir::Block,
5170 expected_ty: Ty<'tcx>,
5172 // Be helpful when the user wrote `{... expr;}` and
5173 // taking the `;` off is enough to fix the error.
5174 let last_stmt = blk.stmts.last()?;
5175 let last_expr = match last_stmt.node {
5176 hir::StmtKind::Semi(ref e) => e,
5179 let last_expr_ty = self.node_ty(last_expr.hir_id);
5180 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5183 let original_span = original_sp(last_stmt.span, blk.span);
5184 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5187 // Rewrite `SelfCtor` to `Ctor`
5188 pub fn rewrite_self_ctor(
5192 ) -> Result<Res, ErrorReported> {
5194 if let Res::SelfCtor(impl_def_id) = res {
5195 let ty = self.impl_self_ty(span, impl_def_id).ty;
5196 let adt_def = ty.ty_adt_def();
5199 Some(adt_def) if adt_def.has_ctor() => {
5200 let variant = adt_def.non_enum_variant();
5201 let ctor_def_id = variant.ctor_def_id.unwrap();
5202 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5205 let mut err = tcx.sess.struct_span_err(span,
5206 "the `Self` constructor can only be used with tuple or unit structs");
5207 if let Some(adt_def) = adt_def {
5208 match adt_def.adt_kind() {
5210 err.help("did you mean to use one of the enum's variants?");
5214 err.span_suggestion(
5216 "use curly brackets",
5217 String::from("Self { /* fields */ }"),
5218 Applicability::HasPlaceholders,
5233 // Instantiates the given path, which must refer to an item with the given
5234 // number of type parameters and type.
5235 pub fn instantiate_value_path(&self,
5236 segments: &[hir::PathSegment],
5237 self_ty: Option<Ty<'tcx>>,
5241 -> (Ty<'tcx>, Res) {
5243 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5252 let res = match self.rewrite_self_ctor(res, span) {
5254 Err(ErrorReported) => return (tcx.types.err, res),
5256 let path_segs = match res {
5257 Res::Local(_) => vec![],
5258 Res::Def(kind, def_id) =>
5259 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5260 _ => bug!("instantiate_value_path on {:?}", res),
5263 let mut user_self_ty = None;
5264 let mut is_alias_variant_ctor = false;
5266 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5267 if let Some(self_ty) = self_ty {
5268 let adt_def = self_ty.ty_adt_def().unwrap();
5269 user_self_ty = Some(UserSelfTy {
5270 impl_def_id: adt_def.did,
5273 is_alias_variant_ctor = true;
5276 Res::Def(DefKind::Method, def_id)
5277 | Res::Def(DefKind::AssocConst, def_id) => {
5278 let container = tcx.associated_item(def_id).container;
5279 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5281 ty::TraitContainer(trait_did) => {
5282 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5284 ty::ImplContainer(impl_def_id) => {
5285 if segments.len() == 1 {
5286 // `<T>::assoc` will end up here, and so
5287 // can `T::assoc`. It this came from an
5288 // inherent impl, we need to record the
5289 // `T` for posterity (see `UserSelfTy` for
5291 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5292 user_self_ty = Some(UserSelfTy {
5303 // Now that we have categorized what space the parameters for each
5304 // segment belong to, let's sort out the parameters that the user
5305 // provided (if any) into their appropriate spaces. We'll also report
5306 // errors if type parameters are provided in an inappropriate place.
5308 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5309 let generics_has_err = AstConv::prohibit_generics(
5310 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5311 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5318 if let Res::Local(hid) = res {
5319 let ty = self.local_ty(span, hid).decl_ty;
5320 let ty = self.normalize_associated_types_in(span, &ty);
5321 self.write_ty(hir_id, ty);
5325 if generics_has_err {
5326 // Don't try to infer type parameters when prohibited generic arguments were given.
5327 user_self_ty = None;
5330 // Now we have to compare the types that the user *actually*
5331 // provided against the types that were *expected*. If the user
5332 // did not provide any types, then we want to substitute inference
5333 // variables. If the user provided some types, we may still need
5334 // to add defaults. If the user provided *too many* types, that's
5337 let mut infer_args_for_err = FxHashSet::default();
5338 for &PathSeg(def_id, index) in &path_segs {
5339 let seg = &segments[index];
5340 let generics = tcx.generics_of(def_id);
5341 // Argument-position `impl Trait` is treated as a normal generic
5342 // parameter internally, but we don't allow users to specify the
5343 // parameter's value explicitly, so we have to do some error-
5345 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5350 false, // `is_method_call`
5352 if suppress_errors {
5353 infer_args_for_err.insert(index);
5354 self.set_tainted_by_errors(); // See issue #53251.
5358 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5359 tcx.generics_of(*def_id).has_self
5360 }).unwrap_or(false);
5362 let def_id = res.def_id();
5364 // The things we are substituting into the type should not contain
5365 // escaping late-bound regions, and nor should the base type scheme.
5366 let ty = tcx.type_of(def_id);
5368 let substs = AstConv::create_substs_for_generic_args(
5374 // Provide the generic args, and whether types should be inferred.
5376 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5379 // If we've encountered an `impl Trait`-related error, we're just
5380 // going to infer the arguments for better error messages.
5381 if !infer_args_for_err.contains(&index) {
5382 // Check whether the user has provided generic arguments.
5383 if let Some(ref data) = segments[index].args {
5384 return (Some(data), segments[index].infer_types);
5387 return (None, segments[index].infer_types);
5392 // Provide substitutions for parameters for which (valid) arguments have been provided.
5394 match (¶m.kind, arg) {
5395 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5396 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5398 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5399 self.to_ty(ty).into()
5401 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5402 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5404 _ => unreachable!(),
5407 // Provide substitutions for parameters for which arguments are inferred.
5408 |substs, param, infer_types| {
5410 GenericParamDefKind::Lifetime => {
5411 self.re_infer(span, Some(param)).unwrap().into()
5413 GenericParamDefKind::Type { has_default, .. } => {
5414 if !infer_types && has_default {
5415 // If we have a default, then we it doesn't matter that we're not
5416 // inferring the type arguments: we provide the default where any
5418 let default = tcx.type_of(param.def_id);
5421 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5424 // If no type arguments were provided, we have to infer them.
5425 // This case also occurs as a result of some malformed input, e.g.
5426 // a lifetime argument being given instead of a type parameter.
5427 // Using inference instead of `Error` gives better error messages.
5428 self.var_for_def(span, param)
5431 GenericParamDefKind::Const => {
5432 // FIXME(const_generics:defaults)
5433 // No const parameters were provided, we have to infer them.
5434 self.var_for_def(span, param)
5439 assert!(!substs.has_escaping_bound_vars());
5440 assert!(!ty.has_escaping_bound_vars());
5442 // First, store the "user substs" for later.
5443 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5445 // Add all the obligations that are required, substituting and
5446 // normalized appropriately.
5447 let bounds = self.instantiate_bounds(span, def_id, &substs);
5448 self.add_obligations_for_parameters(
5449 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5452 // Substitute the values for the type parameters into the type of
5453 // the referenced item.
5454 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5456 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5457 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5458 // is inherent, there is no `Self` parameter; instead, the impl needs
5459 // type parameters, which we can infer by unifying the provided `Self`
5460 // with the substituted impl type.
5461 // This also occurs for an enum variant on a type alias.
5462 let ty = tcx.type_of(impl_def_id);
5464 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5465 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5466 Ok(ok) => self.register_infer_ok_obligations(ok),
5468 self.tcx.sess.delay_span_bug(span, &format!(
5469 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5477 self.check_rustc_args_require_const(def_id, hir_id, span);
5479 debug!("instantiate_value_path: type of {:?} is {:?}",
5482 self.write_substs(hir_id, substs);
5484 (ty_substituted, res)
5487 fn check_rustc_args_require_const(&self,
5491 // We're only interested in functions tagged with
5492 // #[rustc_args_required_const], so ignore anything that's not.
5493 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5497 // If our calling expression is indeed the function itself, we're good!
5498 // If not, generate an error that this can only be called directly.
5499 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5500 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5502 if let ExprKind::Call(ref callee, ..) = expr.node {
5503 if callee.hir_id == hir_id {
5509 self.tcx.sess.span_err(span, "this function can only be invoked \
5510 directly, not through a function pointer");
5513 // Resolves `typ` by a single level if `typ` is a type variable.
5514 // If no resolution is possible, then an error is reported.
5515 // Numeric inference variables may be left unresolved.
5516 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5517 let ty = self.resolve_type_vars_with_obligations(ty);
5518 if !ty.is_ty_var() {
5521 if !self.is_tainted_by_errors() {
5522 self.need_type_info_err((**self).body_id, sp, ty)
5523 .note("type must be known at this point")
5526 self.demand_suptype(sp, self.tcx.types.err, ty);
5531 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5532 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5533 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5536 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5537 index = enclosing_breakables.stack.len();
5538 enclosing_breakables.by_id.insert(id, index);
5539 enclosing_breakables.stack.push(ctxt);
5543 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5544 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5545 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5546 enclosing_breakables.stack.pop().expect("missing breakable context")
5551 /// Instantiate a QueryResponse in a probe context, without a
5552 /// good ObligationCause.
5553 fn probe_instantiate_query_response(
5556 original_values: &OriginalQueryValues<'tcx>,
5557 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5558 ) -> InferResult<'tcx, Ty<'tcx>>
5560 self.instantiate_query_response_and_region_obligations(
5561 &traits::ObligationCause::misc(span, self.body_id),
5567 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5568 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5569 let mut contained_in_place = false;
5571 while let hir::Node::Expr(parent_expr) =
5572 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5574 match &parent_expr.node {
5575 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5576 if lhs.hir_id == expr_id {
5577 contained_in_place = true;
5583 expr_id = parent_expr.hir_id;
5590 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5591 generics: &ty::Generics,
5593 let own_counts = generics.own_counts();
5595 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5601 if own_counts.types == 0 {
5605 // Make a vector of booleans initially false, set to true when used.
5606 let mut types_used = vec![false; own_counts.types];
5608 for leaf_ty in ty.walk() {
5609 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5610 debug!("Found use of ty param num {}", index);
5611 types_used[index as usize - own_counts.lifetimes] = true;
5612 } else if let ty::Error = leaf_ty.sty {
5613 // If there is already another error, do not emit
5614 // an error for not using a type Parameter.
5615 assert!(tcx.sess.err_count() > 0);
5620 let types = generics.params.iter().filter(|param| match param.kind {
5621 ty::GenericParamDefKind::Type { .. } => true,
5624 for (&used, param) in types_used.iter().zip(types) {
5626 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5627 let span = tcx.hir().span_by_hir_id(id);
5628 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5629 .span_label(span, "unused type parameter")
5635 fn fatally_break_rust(sess: &Session) {
5636 let handler = sess.diagnostic();
5637 handler.span_bug_no_panic(
5639 "It looks like you're trying to break rust; would you like some ICE?",
5641 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5642 handler.note_without_error(
5643 "we would appreciate a joke overview: \
5644 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5646 handler.note_without_error(&format!("rustc {} running on {}",
5647 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5648 crate::session::config::host_triple(),
5652 fn potentially_plural_count(count: usize, word: &str) -> String {
5653 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })