5 Within the check phase of type check, we check each item one at a time
6 (bodies of function expressions are checked as part of the containing
7 function). Inference is used to supply types wherever they are unknown.
9 By far the most complex case is checking the body of a function. This
10 can be broken down into several distinct phases:
12 - gather: creates type variables to represent the type of each local
13 variable and pattern binding.
15 - main: the main pass does the lion's share of the work: it
16 determines the types of all expressions, resolves
17 methods, checks for most invalid conditions, and so forth. In
18 some cases, where a type is unknown, it may create a type or region
19 variable and use that as the type of an expression.
21 In the process of checking, various constraints will be placed on
22 these type variables through the subtyping relationships requested
23 through the `demand` module. The `infer` module is in charge
24 of resolving those constraints.
26 - regionck: after main is complete, the regionck pass goes over all
27 types looking for regions and making sure that they did not escape
28 into places they are not in scope. This may also influence the
29 final assignments of the various region variables if there is some
32 - vtable: find and records the impls to use for each trait bound that
33 appears on a type parameter.
35 - writeback: writes the final types within a function body, replacing
36 type variables with their final inferred types. These final types
37 are written into the `tcx.node_types` table, which should *never* contain
38 any reference to a type variable.
42 While type checking a function, the intermediate types for the
43 expressions, blocks, and so forth contained within the function are
44 stored in `fcx.node_types` and `fcx.node_substs`. These types
45 may contain unresolved type variables. After type checking is
46 complete, the functions in the writeback module are used to take the
47 types from this table, resolve them, and then write them into their
48 permanent home in the type context `tcx`.
50 This means that during inferencing you should use `fcx.write_ty()`
51 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
52 nodes within the function.
54 The types of top-level items, which never contain unbound type
55 variables, are stored directly into the `tcx` tables.
57 N.B., a type variable is not the same thing as a type parameter. A
58 type variable is rather an "instance" of a type parameter: that is,
59 given a generic function `fn foo<T>(t: T)`: while checking the
60 function `foo`, the type `ty_param(0)` refers to the type `T`, which
61 is treated in abstract. When `foo()` is called, however, `T` will be
62 substituted for a fresh type variable `N`. This variable will
63 eventually be resolved to some concrete type (which might itself be
82 mod generator_interior;
86 use crate::astconv::{AstConv, PathSeg};
87 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
88 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
89 use rustc::hir::def::{CtorKind, Def};
90 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
91 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
92 use rustc::hir::itemlikevisit::ItemLikeVisitor;
93 use crate::middle::lang_items;
94 use crate::namespace::Namespace;
95 use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin};
96 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
97 use rustc_data_structures::indexed_vec::Idx;
98 use rustc_data_structures::sync::Lrc;
99 use rustc_target::spec::abi::Abi;
100 use rustc::infer::opaque_types::OpaqueTypeDecl;
101 use rustc::infer::type_variable::{TypeVariableOrigin};
102 use rustc::middle::region;
103 use rustc::mir::interpret::{ConstValue, GlobalId};
104 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
106 self, AdtKind, CanonicalUserType, Ty, TyCtxt, GenericParamDefKind, Visibility,
107 ToPolyTraitRef, ToPredicate, RegionKind, UserType
109 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
110 use rustc::ty::fold::TypeFoldable;
111 use rustc::ty::query::Providers;
112 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
113 use rustc::ty::util::{Representability, IntTypeExt, Discr};
114 use rustc::ty::layout::VariantIdx;
115 use syntax_pos::{self, BytePos, Span, MultiSpan};
118 use syntax::feature_gate::{GateIssue, emit_feature_err};
120 use syntax::source_map::{DUMMY_SP, original_sp};
121 use syntax::symbol::{Symbol, LocalInternedString, keywords};
122 use syntax::util::lev_distance::find_best_match_for_name;
124 use std::cell::{Cell, RefCell, Ref, RefMut};
125 use std::collections::hash_map::Entry;
127 use std::fmt::Display;
129 use std::mem::replace;
130 use std::ops::{self, Deref};
133 use crate::require_c_abi_if_c_variadic;
134 use crate::session::Session;
135 use crate::session::config::EntryFnType;
136 use crate::TypeAndSubsts;
138 use crate::util::captures::Captures;
139 use crate::util::common::{ErrorReported, indenter};
140 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
142 pub use self::Expectation::*;
143 use self::autoderef::Autoderef;
144 use self::callee::DeferredCallResolution;
145 use self::coercion::{CoerceMany, DynamicCoerceMany};
146 pub use self::compare_method::{compare_impl_method, compare_const_impl};
147 use self::method::{MethodCallee, SelfSource};
148 use self::TupleArgumentsFlag::*;
150 /// The type of a local binding, including the revealed type for anon types.
151 #[derive(Copy, Clone)]
152 pub struct LocalTy<'tcx> {
154 revealed_ty: Ty<'tcx>
157 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
158 #[derive(Copy, Clone)]
159 struct MaybeInProgressTables<'a, 'tcx: 'a> {
160 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
163 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
164 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
165 match self.maybe_tables {
166 Some(tables) => tables.borrow(),
168 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
173 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
174 match self.maybe_tables {
175 Some(tables) => tables.borrow_mut(),
177 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
183 /// Closures defined within the function. For example:
186 /// bar(move|| { ... })
189 /// Here, the function `foo()` and the closure passed to
190 /// `bar()` will each have their own `FnCtxt`, but they will
191 /// share the inherited fields.
192 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
193 infcx: InferCtxt<'a, 'gcx, 'tcx>,
195 tables: MaybeInProgressTables<'a, 'tcx>,
197 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
199 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
201 // Some additional `Sized` obligations badly affect type inference.
202 // These obligations are added in a later stage of typeck.
203 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
205 // When we process a call like `c()` where `c` is a closure type,
206 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
207 // `FnOnce` closure. In that case, we defer full resolution of the
208 // call until upvar inference can kick in and make the
209 // decision. We keep these deferred resolutions grouped by the
210 // def-id of the closure, so that once we decide, we can easily go
211 // back and process them.
212 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
214 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
216 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
218 // Opaque types found in explicit return types and their
219 // associated fresh inference variable. Writeback resolves these
220 // variables to get the concrete type, which can be used to
221 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
222 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
224 /// Each type parameter has an implicit region bound that
225 /// indicates it must outlive at least the function body (the user
226 /// may specify stronger requirements). This field indicates the
227 /// region of the callee. If it is `None`, then the parameter
228 /// environment is for an item or something where the "callee" is
230 implicit_region_bound: Option<ty::Region<'tcx>>,
232 body_id: Option<hir::BodyId>,
235 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
236 type Target = InferCtxt<'a, 'gcx, 'tcx>;
237 fn deref(&self) -> &Self::Target {
242 /// When type-checking an expression, we propagate downward
243 /// whatever type hint we are able in the form of an `Expectation`.
244 #[derive(Copy, Clone, Debug)]
245 pub enum Expectation<'tcx> {
246 /// We know nothing about what type this expression should have.
249 /// This expression is an `if` condition, it must resolve to `bool`.
252 /// This expression should have the type given (or some subtype).
253 ExpectHasType(Ty<'tcx>),
255 /// This expression will be cast to the `Ty`.
256 ExpectCastableToType(Ty<'tcx>),
258 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
259 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
260 ExpectRvalueLikeUnsized(Ty<'tcx>),
263 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
264 // Disregard "castable to" expectations because they
265 // can lead us astray. Consider for example `if cond
266 // {22} else {c} as u8` -- if we propagate the
267 // "castable to u8" constraint to 22, it will pick the
268 // type 22u8, which is overly constrained (c might not
269 // be a u8). In effect, the problem is that the
270 // "castable to" expectation is not the tightest thing
271 // we can say, so we want to drop it in this case.
272 // The tightest thing we can say is "must unify with
273 // else branch". Note that in the case of a "has type"
274 // constraint, this limitation does not hold.
276 // If the expected type is just a type variable, then don't use
277 // an expected type. Otherwise, we might write parts of the type
278 // when checking the 'then' block which are incompatible with the
280 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
282 ExpectHasType(ety) => {
283 let ety = fcx.shallow_resolve(ety);
284 if !ety.is_ty_var() {
290 ExpectRvalueLikeUnsized(ety) => {
291 ExpectRvalueLikeUnsized(ety)
297 /// Provides an expectation for an rvalue expression given an *optional*
298 /// hint, which is not required for type safety (the resulting type might
299 /// be checked higher up, as is the case with `&expr` and `box expr`), but
300 /// is useful in determining the concrete type.
302 /// The primary use case is where the expected type is a fat pointer,
303 /// like `&[isize]`. For example, consider the following statement:
305 /// let x: &[isize] = &[1, 2, 3];
307 /// In this case, the expected type for the `&[1, 2, 3]` expression is
308 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
309 /// expectation `ExpectHasType([isize])`, that would be too strong --
310 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
311 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
312 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
313 /// which still is useful, because it informs integer literals and the like.
314 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
315 /// for examples of where this comes up,.
316 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
317 match fcx.tcx.struct_tail(ty).sty {
318 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
319 ExpectRvalueLikeUnsized(ty)
321 _ => ExpectHasType(ty)
325 // Resolves `expected` by a single level if it is a variable. If
326 // there is no expected type or resolution is not possible (e.g.,
327 // no constraints yet present), just returns `None`.
328 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
330 NoExpectation => NoExpectation,
331 ExpectIfCondition => ExpectIfCondition,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_type_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_type_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_type_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 ExpectIfCondition => Some(fcx.tcx.types.bool),
348 ExpectCastableToType(ty) |
350 ExpectRvalueLikeUnsized(ty) => Some(ty),
354 /// It sometimes happens that we want to turn an expectation into
355 /// a **hard constraint** (i.e., something that must be satisfied
356 /// for the program to type-check). `only_has_type` will return
357 /// such a constraint, if it exists.
358 fn only_has_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
359 match self.resolve(fcx) {
360 ExpectHasType(ty) => Some(ty),
361 ExpectIfCondition => Some(fcx.tcx.types.bool),
362 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
366 /// Like `only_has_type`, but instead of returning `None` if no
367 /// hard constraint exists, creates a fresh type variable.
368 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
369 self.only_has_type(fcx)
370 .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span)))
374 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
381 fn maybe_mut_place(m: hir::Mutability) -> Self {
383 hir::MutMutable => Needs::MutPlace,
384 hir::MutImmutable => Needs::None,
389 #[derive(Copy, Clone)]
390 pub struct UnsafetyState {
392 pub unsafety: hir::Unsafety,
393 pub unsafe_push_count: u32,
398 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
399 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
402 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
403 match self.unsafety {
404 // If this unsafe, then if the outer function was already marked as
405 // unsafe we shouldn't attribute the unsafe'ness to the block. This
406 // way the block can be warned about instead of ignoring this
407 // extraneous block (functions are never warned about).
408 hir::Unsafety::Unsafe if self.from_fn => *self,
411 let (unsafety, def, count) = match blk.rules {
412 hir::PushUnsafeBlock(..) =>
413 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
414 hir::PopUnsafeBlock(..) =>
415 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
416 hir::UnsafeBlock(..) =>
417 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
419 (unsafety, self.def, self.unsafe_push_count),
423 unsafe_push_count: count,
430 #[derive(Debug, Copy, Clone)]
436 /// Tracks whether executing a node may exit normally (versus
437 /// return/break/panic, which "diverge", leaving dead code in their
438 /// wake). Tracked semi-automatically (through type variables marked
439 /// as diverging), with some manual adjustments for control-flow
440 /// primitives (approximating a CFG).
441 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
443 /// Potentially unknown, some cases converge,
444 /// others require a CFG to determine them.
447 /// Definitely known to diverge and therefore
448 /// not reach the next sibling or its parent.
451 /// Same as `Always` but with a reachability
452 /// warning already emitted.
456 // Convenience impls for combinig `Diverges`.
458 impl ops::BitAnd for Diverges {
460 fn bitand(self, other: Self) -> Self {
461 cmp::min(self, other)
465 impl ops::BitOr for Diverges {
467 fn bitor(self, other: Self) -> Self {
468 cmp::max(self, other)
472 impl ops::BitAndAssign for Diverges {
473 fn bitand_assign(&mut self, other: Self) {
474 *self = *self & other;
478 impl ops::BitOrAssign for Diverges {
479 fn bitor_assign(&mut self, other: Self) {
480 *self = *self | other;
485 fn always(self) -> bool {
486 self >= Diverges::Always
490 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
493 // this is `null` for loops where break with a value is illegal,
494 // such as `while`, `for`, and `while let`
495 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
498 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
499 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
500 by_id: HirIdMap<usize>,
503 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
504 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
505 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
506 bug!("could not find enclosing breakable with id {}", target_id);
512 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
515 /// The parameter environment used for proving trait obligations
516 /// in this function. This can change when we descend into
517 /// closures (as they bring new things into scope), hence it is
518 /// not part of `Inherited` (as of the time of this writing,
519 /// closures do not yet change the environment, but they will
521 param_env: ty::ParamEnv<'tcx>,
523 // Number of errors that had been reported when we started
524 // checking this function. On exit, if we find that *more* errors
525 // have been reported, we will skip regionck and other work that
526 // expects the types within the function to be consistent.
527 err_count_on_creation: usize,
529 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
530 ret_coercion_span: RefCell<Option<Span>>,
532 yield_ty: Option<Ty<'tcx>>,
534 ps: RefCell<UnsafetyState>,
536 /// Whether the last checked node generates a divergence (e.g.,
537 /// `return` will set this to `Always`). In general, when entering
538 /// an expression or other node in the tree, the initial value
539 /// indicates whether prior parts of the containing expression may
540 /// have diverged. It is then typically set to `Maybe` (and the
541 /// old value remembered) for processing the subparts of the
542 /// current expression. As each subpart is processed, they may set
543 /// the flag to `Always`, etc. Finally, at the end, we take the
544 /// result and "union" it with the original value, so that when we
545 /// return the flag indicates if any subpart of the parent
546 /// expression (up to and including this part) has diverged. So,
547 /// if you read it after evaluating a subexpression `X`, the value
548 /// you get indicates whether any subexpression that was
549 /// evaluating up to and including `X` diverged.
551 /// We currently use this flag only for diagnostic purposes:
553 /// - To warn about unreachable code: if, after processing a
554 /// sub-expression but before we have applied the effects of the
555 /// current node, we see that the flag is set to `Always`, we
556 /// can issue a warning. This corresponds to something like
557 /// `foo(return)`; we warn on the `foo()` expression. (We then
558 /// update the flag to `WarnedAlways` to suppress duplicate
559 /// reports.) Similarly, if we traverse to a fresh statement (or
560 /// tail expression) from a `Always` setting, we will issue a
561 /// warning. This corresponds to something like `{return;
562 /// foo();}` or `{return; 22}`, where we would warn on the
565 /// An expression represents dead code if, after checking it,
566 /// the diverges flag is set to something other than `Maybe`.
567 diverges: Cell<Diverges>,
569 /// Whether any child nodes have any type errors.
570 has_errors: Cell<bool>,
572 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
574 inh: &'a Inherited<'a, 'gcx, 'tcx>,
577 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
578 type Target = Inherited<'a, 'gcx, 'tcx>;
579 fn deref(&self) -> &Self::Target {
584 /// Helper type of a temporary returned by `Inherited::build(...)`.
585 /// Necessary because we can't write the following bound:
586 /// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
587 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
588 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
592 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
593 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
594 -> InheritedBuilder<'a, 'gcx, 'tcx> {
595 let hir_id_root = if def_id.is_local() {
596 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
597 DefId::local(hir_id.owner)
603 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
609 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
610 fn enter<F, R>(&'tcx mut self, f: F) -> R
611 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
613 let def_id = self.def_id;
614 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
618 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
619 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
621 let item_id = tcx.hir().as_local_hir_id(def_id);
622 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
623 let implicit_region_bound = body_id.map(|body_id| {
624 let body = tcx.hir().body(body_id);
625 tcx.mk_region(ty::ReScope(region::Scope {
626 id: body.value.hir_id.local_id,
627 data: region::ScopeData::CallSite
632 tables: MaybeInProgressTables {
633 maybe_tables: infcx.in_progress_tables,
636 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
637 locals: RefCell::new(Default::default()),
638 deferred_sized_obligations: RefCell::new(Vec::new()),
639 deferred_call_resolutions: RefCell::new(Default::default()),
640 deferred_cast_checks: RefCell::new(Vec::new()),
641 deferred_generator_interiors: RefCell::new(Vec::new()),
642 opaque_types: RefCell::new(Default::default()),
643 implicit_region_bound,
648 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
649 debug!("register_predicate({:?})", obligation);
650 if obligation.has_escaping_bound_vars() {
651 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
656 .register_predicate_obligation(self, obligation);
659 fn register_predicates<I>(&self, obligations: I)
660 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
662 for obligation in obligations {
663 self.register_predicate(obligation);
667 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
668 self.register_predicates(infer_ok.obligations);
672 fn normalize_associated_types_in<T>(&self,
675 param_env: ty::ParamEnv<'tcx>,
677 where T : TypeFoldable<'tcx>
679 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
680 self.register_infer_ok_obligations(ok)
684 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
686 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
687 fn visit_item(&mut self, i: &'tcx hir::Item) {
688 check_item_type(self.tcx, i);
690 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
691 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
694 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
695 tcx.sess.track_errors(|| {
696 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
697 tcx.hir().krate().visit_all_item_likes(&mut visit);
701 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
702 tcx.sess.track_errors(|| {
703 for &module in tcx.hir().krate().modules.keys() {
704 tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
709 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
710 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
713 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
714 tcx.typeck_item_bodies(LOCAL_CRATE)
717 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
718 -> Result<(), ErrorReported>
720 debug_assert!(crate_num == LOCAL_CRATE);
721 Ok(tcx.sess.track_errors(|| {
722 tcx.par_body_owners(|body_owner_def_id| {
723 tcx.ensure().typeck_tables_of(body_owner_def_id);
728 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
729 wfcheck::check_item_well_formed(tcx, def_id);
732 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
733 wfcheck::check_trait_item(tcx, def_id);
736 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
737 wfcheck::check_impl_item(tcx, def_id);
740 pub fn provide(providers: &mut Providers<'_>) {
741 method::provide(providers);
742 *providers = Providers {
748 check_item_well_formed,
749 check_trait_item_well_formed,
750 check_impl_item_well_formed,
751 check_mod_item_types,
756 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
758 -> Option<ty::Destructor> {
759 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
762 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
763 /// with information about it's body-id and fn-decl (if any). Otherwise,
766 /// If this function returns "some", then `typeck_tables(def_id)` will
767 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
768 /// may not succeed. In some cases where this function returns `None`
769 /// (notably closures), `typeck_tables(def_id)` would wind up
770 /// redirecting to the owning function.
771 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
773 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
775 match tcx.hir().get_by_hir_id(id) {
776 Node::Item(item) => {
778 hir::ItemKind::Const(_, body) |
779 hir::ItemKind::Static(_, _, body) =>
781 hir::ItemKind::Fn(ref decl, .., body) =>
782 Some((body, Some(decl))),
787 Node::TraitItem(item) => {
789 hir::TraitItemKind::Const(_, Some(body)) =>
791 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
792 Some((body, Some(&sig.decl))),
797 Node::ImplItem(item) => {
799 hir::ImplItemKind::Const(_, body) =>
801 hir::ImplItemKind::Method(ref sig, body) =>
802 Some((body, Some(&sig.decl))),
807 Node::AnonConst(constant) => Some((constant.body, None)),
812 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
815 // Closures' tables come from their outermost function,
816 // as they are part of the same "inference environment".
817 let outer_def_id = tcx.closure_base_def_id(def_id);
818 if outer_def_id != def_id {
819 return tcx.has_typeck_tables(outer_def_id);
822 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
823 primary_body_of(tcx, id).is_some()
826 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
829 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
832 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
834 -> &'tcx ty::TypeckTables<'tcx> {
835 // Closures' tables come from their outermost function,
836 // as they are part of the same "inference environment".
837 let outer_def_id = tcx.closure_base_def_id(def_id);
838 if outer_def_id != def_id {
839 return tcx.typeck_tables_of(outer_def_id);
842 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
843 let span = tcx.hir().span_by_hir_id(id);
845 // Figure out what primary body this item has.
846 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
847 span_bug!(span, "can't type-check body of {:?}", def_id);
849 let body = tcx.hir().body(body_id);
851 let tables = Inherited::build(tcx, def_id).enter(|inh| {
852 let param_env = tcx.param_env(def_id);
853 let fcx = if let Some(decl) = fn_decl {
854 let fn_sig = tcx.fn_sig(def_id);
856 check_abi(tcx, span, fn_sig.abi());
858 // Compute the fty from point of view of inside the fn.
860 tcx.liberate_late_bound_regions(def_id, &fn_sig);
862 inh.normalize_associated_types_in(body.value.span,
867 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
870 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
871 let expected_type = tcx.type_of(def_id);
872 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
873 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
875 let revealed_ty = if tcx.features().impl_trait_in_bindings {
876 fcx.instantiate_opaque_types_from_value(
884 // Gather locals in statics (because of block expressions).
885 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
887 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
892 // All type checking constraints were added, try to fallback unsolved variables.
893 fcx.select_obligations_where_possible(false);
894 let mut fallback_has_occurred = false;
895 for ty in &fcx.unsolved_variables() {
896 fallback_has_occurred |= fcx.fallback_if_possible(ty);
898 fcx.select_obligations_where_possible(fallback_has_occurred);
900 // Even though coercion casts provide type hints, we check casts after fallback for
901 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
904 // Closure and generator analysis may run after fallback
905 // because they don't constrain other type variables.
906 fcx.closure_analyze(body);
907 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
908 fcx.resolve_generator_interiors(def_id);
910 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
911 let ty = fcx.normalize_ty(span, ty);
912 fcx.require_type_is_sized(ty, span, code);
914 fcx.select_all_obligations_or_error();
916 if fn_decl.is_some() {
917 fcx.regionck_fn(id, body);
919 fcx.regionck_expr(body);
922 fcx.resolve_type_vars_in_body(body)
925 // Consistency check our TypeckTables instance can hold all ItemLocalIds
926 // it will need to hold.
927 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
932 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
933 if !tcx.sess.target.target.is_abi_supported(abi) {
934 struct_span_err!(tcx.sess, span, E0570,
935 "The ABI `{}` is not supported for the current target", abi).emit()
939 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
940 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
941 parent_id: hir::HirId,
944 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
945 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
948 // infer the variable's type
949 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
950 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
957 // take type that the user specified
958 self.fcx.locals.borrow_mut().insert(nid, typ);
965 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
966 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
967 NestedVisitorMap::None
970 // Add explicitly-declared locals.
971 fn visit_local(&mut self, local: &'gcx hir::Local) {
972 let local_ty = match local.ty {
974 let o_ty = self.fcx.to_ty(&ty);
976 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
977 self.fcx.instantiate_opaque_types_from_value(
985 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
986 &UserType::Ty(revealed_ty)
988 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
989 ty.hir_id, o_ty, revealed_ty, c_ty);
990 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
992 Some(LocalTy { decl_ty: o_ty, revealed_ty })
996 self.assign(local.span, local.hir_id, local_ty);
998 debug!("Local variable {:?} is assigned type {}",
1000 self.fcx.ty_to_string(
1001 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1002 intravisit::walk_local(self, local);
1005 // Add pattern bindings.
1006 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1007 if let PatKind::Binding(_, _, ident, _) = p.node {
1008 let var_ty = self.assign(p.span, p.hir_id, None);
1010 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
1011 if !self.fcx.tcx.features().unsized_locals {
1012 self.fcx.require_type_is_sized(var_ty, p.span,
1013 traits::VariableType(node_id));
1016 debug!("Pattern binding {} is assigned to {} with type {:?}",
1018 self.fcx.ty_to_string(
1019 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1022 intravisit::walk_pat(self, p);
1025 // Don't descend into the bodies of nested closures
1026 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1027 _: hir::BodyId, _: Span, _: hir::HirId) { }
1030 /// When `check_fn` is invoked on a generator (i.e., a body that
1031 /// includes yield), it returns back some information about the yield
1033 struct GeneratorTypes<'tcx> {
1034 /// Type of value that is yielded.
1035 yield_ty: ty::Ty<'tcx>,
1037 /// Types that are captured (see `GeneratorInterior` for more).
1038 interior: ty::Ty<'tcx>,
1040 /// Indicates if the generator is movable or static (immovable).
1041 movability: hir::GeneratorMovability,
1044 /// Helper used for fns and closures. Does the grungy work of checking a function
1045 /// body and returns the function context used for that purpose, since in the case of a fn item
1046 /// there is still a bit more to do.
1049 /// * inherited: other fields inherited from the enclosing fn (if any)
1050 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1051 param_env: ty::ParamEnv<'tcx>,
1052 fn_sig: ty::FnSig<'tcx>,
1053 decl: &'gcx hir::FnDecl,
1055 body: &'gcx hir::Body,
1056 can_be_generator: Option<hir::GeneratorMovability>)
1057 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1059 let mut fn_sig = fn_sig.clone();
1061 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1063 // Create the function context. This is either derived from scratch or,
1064 // in the case of closures, based on the outer context.
1065 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1066 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1068 let declared_ret_ty = fn_sig.output();
1069 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1070 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1071 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1072 fn_sig = fcx.tcx.mk_fn_sig(
1073 fn_sig.inputs().iter().cloned(),
1080 let span = body.value.span;
1082 if body.is_generator && can_be_generator.is_some() {
1083 let yield_ty = fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
1084 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1085 fcx.yield_ty = Some(yield_ty);
1088 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1089 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1090 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1092 // Add formal parameters.
1093 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1094 // Check the pattern.
1098 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
1102 // Check that argument is Sized.
1103 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1104 // for simple cases like `fn foo(x: Trait)`,
1105 // where we would error once on the parameter as a whole, and once on the binding `x`.
1106 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1107 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1110 fcx.write_ty(arg.hir_id, arg_ty);
1113 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1115 fcx.check_return_expr(&body.value);
1117 // We insert the deferred_generator_interiors entry after visiting the body.
1118 // This ensures that all nested generators appear before the entry of this generator.
1119 // resolve_generator_interiors relies on this property.
1120 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1121 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1122 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1123 Some(GeneratorTypes {
1124 yield_ty: fcx.yield_ty.unwrap(),
1126 movability: can_be_generator.unwrap(),
1132 // Finalize the return check by taking the LUB of the return types
1133 // we saw and assigning it to the expected return type. This isn't
1134 // really expected to fail, since the coercions would have failed
1135 // earlier when trying to find a LUB.
1137 // However, the behavior around `!` is sort of complex. In the
1138 // event that the `actual_return_ty` comes back as `!`, that
1139 // indicates that the fn either does not return or "returns" only
1140 // values of type `!`. In this case, if there is an expected
1141 // return type that is *not* `!`, that should be ok. But if the
1142 // return type is being inferred, we want to "fallback" to `!`:
1144 // let x = move || panic!();
1146 // To allow for that, I am creating a type variable with diverging
1147 // fallback. This was deemed ever so slightly better than unifying
1148 // the return value with `!` because it allows for the caller to
1149 // make more assumptions about the return type (e.g., they could do
1151 // let y: Option<u32> = Some(x());
1153 // which would then cause this return type to become `u32`, not
1155 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1156 let mut actual_return_ty = coercion.complete(&fcx);
1157 if actual_return_ty.is_never() {
1158 actual_return_ty = fcx.next_diverging_ty_var(
1159 TypeVariableOrigin::DivergingFn(span));
1161 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1163 // Check that the main return type implements the termination trait.
1164 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1165 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1166 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1167 if main_id == fn_id {
1168 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1169 let trait_ref = ty::TraitRef::new(term_id, substs);
1170 let return_ty_span = decl.output.span();
1171 let cause = traits::ObligationCause::new(
1172 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1174 inherited.register_predicate(
1175 traits::Obligation::new(
1176 cause, param_env, trait_ref.to_predicate()));
1181 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1182 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1183 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1184 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1185 // at this point we don't care if there are duplicate handlers or if the handler has
1186 // the wrong signature as this value we'll be used when writing metadata and that
1187 // only happens if compilation succeeded
1188 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1190 if declared_ret_ty.sty != ty::Never {
1191 fcx.tcx.sess.span_err(
1193 "return type should be `!`",
1197 let inputs = fn_sig.inputs();
1198 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1199 if inputs.len() == 1 {
1200 let arg_is_panic_info = match inputs[0].sty {
1201 ty::Ref(region, ty, mutbl) => match ty.sty {
1202 ty::Adt(ref adt, _) => {
1203 adt.did == panic_info_did &&
1204 mutbl == hir::Mutability::MutImmutable &&
1205 *region != RegionKind::ReStatic
1212 if !arg_is_panic_info {
1213 fcx.tcx.sess.span_err(
1214 decl.inputs[0].span,
1215 "argument should be `&PanicInfo`",
1219 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1220 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1221 if !generics.params.is_empty() {
1222 fcx.tcx.sess.span_err(
1224 "should have no type parameters",
1230 let span = fcx.tcx.sess.source_map().def_span(span);
1231 fcx.tcx.sess.span_err(span, "function should have one argument");
1234 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1239 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1240 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1241 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1242 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1243 if declared_ret_ty.sty != ty::Never {
1244 fcx.tcx.sess.span_err(
1246 "return type should be `!`",
1250 let inputs = fn_sig.inputs();
1251 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1252 if inputs.len() == 1 {
1253 let arg_is_alloc_layout = match inputs[0].sty {
1254 ty::Adt(ref adt, _) => {
1255 adt.did == alloc_layout_did
1260 if !arg_is_alloc_layout {
1261 fcx.tcx.sess.span_err(
1262 decl.inputs[0].span,
1263 "argument should be `Layout`",
1267 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1268 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1269 if !generics.params.is_empty() {
1270 fcx.tcx.sess.span_err(
1272 "`#[alloc_error_handler]` function should have no type \
1279 let span = fcx.tcx.sess.source_map().def_span(span);
1280 fcx.tcx.sess.span_err(span, "function should have one argument");
1283 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1291 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1294 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1295 let def = tcx.adt_def(def_id);
1296 def.destructor(tcx); // force the destructor to be evaluated
1297 check_representable(tcx, span, def_id);
1299 if def.repr.simd() {
1300 check_simd(tcx, span, def_id);
1303 check_transparent(tcx, span, def_id);
1304 check_packed(tcx, span, def_id);
1307 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1310 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1311 let def = tcx.adt_def(def_id);
1312 def.destructor(tcx); // force the destructor to be evaluated
1313 check_representable(tcx, span, def_id);
1315 check_packed(tcx, span, def_id);
1318 fn check_opaque<'a, 'tcx>(
1319 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1321 substs: SubstsRef<'tcx>,
1324 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1325 let mut err = struct_span_err!(
1326 tcx.sess, span, E0720,
1327 "opaque type expands to a recursive type",
1329 err.span_label(span, "expands to self-referential type");
1330 if let ty::Opaque(..) = partially_expanded_type.sty {
1331 err.note("type resolves to itself");
1333 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1339 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1341 "check_item_type(it.hir_id={}, it.name={})",
1343 tcx.item_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1345 let _indenter = indenter();
1347 // Consts can play a role in type-checking, so they are included here.
1348 hir::ItemKind::Static(..) => {
1349 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1350 tcx.typeck_tables_of(def_id);
1351 maybe_check_static_with_link_section(tcx, def_id, it.span);
1353 hir::ItemKind::Const(..) => {
1354 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1356 hir::ItemKind::Enum(ref enum_definition, _) => {
1357 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1359 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1360 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1361 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1362 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1363 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1364 check_impl_items_against_trait(
1371 let trait_def_id = impl_trait_ref.def_id;
1372 check_on_unimplemented(tcx, trait_def_id, it);
1375 hir::ItemKind::Trait(..) => {
1376 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1377 check_on_unimplemented(tcx, def_id, it);
1379 hir::ItemKind::Struct(..) => {
1380 check_struct(tcx, it.hir_id, it.span);
1382 hir::ItemKind::Union(..) => {
1383 check_union(tcx, it.hir_id, it.span);
1385 hir::ItemKind::Existential(..) => {
1386 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1388 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1389 check_opaque(tcx, def_id, substs, it.span);
1391 hir::ItemKind::Ty(..) => {
1392 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1393 let pty_ty = tcx.type_of(def_id);
1394 let generics = tcx.generics_of(def_id);
1395 check_bounds_are_used(tcx, &generics, pty_ty);
1397 hir::ItemKind::ForeignMod(ref m) => {
1398 check_abi(tcx, it.span, m.abi);
1400 if m.abi == Abi::RustIntrinsic {
1401 for item in &m.items {
1402 intrinsic::check_intrinsic_type(tcx, item);
1404 } else if m.abi == Abi::PlatformIntrinsic {
1405 for item in &m.items {
1406 intrinsic::check_platform_intrinsic_type(tcx, item);
1409 for item in &m.items {
1410 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1411 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1412 let mut err = struct_span_err!(
1416 "foreign items may not have type parameters"
1418 err.span_label(item.span, "can't have type parameters");
1419 // FIXME: once we start storing spans for type arguments, turn this into a
1422 "use specialization instead of type parameters by replacing them \
1423 with concrete types like `u32`",
1428 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1429 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1434 _ => { /* nothing to do */ }
1438 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1439 // Only restricted on wasm32 target for now
1440 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1444 // If `#[link_section]` is missing, then nothing to verify
1445 let attrs = tcx.codegen_fn_attrs(id);
1446 if attrs.link_section.is_none() {
1450 // For the wasm32 target statics with #[link_section] are placed into custom
1451 // sections of the final output file, but this isn't link custom sections of
1452 // other executable formats. Namely we can only embed a list of bytes,
1453 // nothing with pointers to anything else or relocations. If any relocation
1454 // show up, reject them here.
1455 let instance = ty::Instance::mono(tcx, id);
1456 let cid = GlobalId {
1460 let param_env = ty::ParamEnv::reveal_all();
1461 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1462 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1465 bug!("Matching on non-ByRef static")
1467 if alloc.relocations.len() != 0 {
1468 let msg = "statics with a custom `#[link_section]` must be a \
1469 simple list of bytes on the wasm target with no \
1470 extra levels of indirection such as references";
1471 tcx.sess.span_err(span, msg);
1476 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1477 trait_def_id: DefId,
1479 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1480 // an error would be reported if this fails.
1481 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1484 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1485 impl_item: &hir::ImplItem,
1488 let mut err = struct_span_err!(
1489 tcx.sess, impl_item.span, E0520,
1490 "`{}` specializes an item from a parent `impl`, but \
1491 that item is not marked `default`",
1493 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1496 match tcx.span_of_impl(parent_impl) {
1498 err.span_label(span, "parent `impl` is here");
1499 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1503 err.note(&format!("parent implementation is in crate `{}`", cname));
1510 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1511 trait_def: &ty::TraitDef,
1512 trait_item: &ty::AssociatedItem,
1514 impl_item: &hir::ImplItem)
1516 let ancestors = trait_def.ancestors(tcx, impl_id);
1518 let kind = match impl_item.node {
1519 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1520 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1521 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1522 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1525 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1526 .map(|node_item| node_item.map(|parent| parent.defaultness));
1528 if let Some(parent) = parent {
1529 if tcx.impl_item_is_final(&parent) {
1530 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1536 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1539 impl_trait_ref: ty::TraitRef<'tcx>,
1540 impl_item_refs: &[hir::ImplItemRef]) {
1541 let impl_span = tcx.sess.source_map().def_span(impl_span);
1543 // If the trait reference itself is erroneous (so the compilation is going
1544 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1545 // isn't populated for such impls.
1546 if impl_trait_ref.references_error() { return; }
1548 // Locate trait definition and items
1549 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1550 let mut overridden_associated_type = None;
1552 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1554 // Check existing impl methods to see if they are both present in trait
1555 // and compatible with trait signature
1556 for impl_item in impl_items() {
1557 let ty_impl_item = tcx.associated_item(
1558 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1559 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1560 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1561 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1563 // Not compatible, but needed for the error message
1564 tcx.associated_items(impl_trait_ref.def_id)
1565 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1568 // Check that impl definition matches trait definition
1569 if let Some(ty_trait_item) = ty_trait_item {
1570 match impl_item.node {
1571 hir::ImplItemKind::Const(..) => {
1572 // Find associated const definition.
1573 if ty_trait_item.kind == ty::AssociatedKind::Const {
1574 compare_const_impl(tcx,
1580 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1581 "item `{}` is an associated const, \
1582 which doesn't match its trait `{}`",
1585 err.span_label(impl_item.span, "does not match trait");
1586 // We can only get the spans from local trait definition
1587 // Same for E0324 and E0325
1588 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1589 err.span_label(trait_span, "item in trait");
1594 hir::ImplItemKind::Method(..) => {
1595 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1596 if ty_trait_item.kind == ty::AssociatedKind::Method {
1597 compare_impl_method(tcx,
1604 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1605 "item `{}` is an associated method, \
1606 which doesn't match its trait `{}`",
1609 err.span_label(impl_item.span, "does not match trait");
1610 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1611 err.span_label(trait_span, "item in trait");
1616 hir::ImplItemKind::Existential(..) |
1617 hir::ImplItemKind::Type(_) => {
1618 if ty_trait_item.kind == ty::AssociatedKind::Type {
1619 if ty_trait_item.defaultness.has_value() {
1620 overridden_associated_type = Some(impl_item);
1623 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1624 "item `{}` is an associated type, \
1625 which doesn't match its trait `{}`",
1628 err.span_label(impl_item.span, "does not match trait");
1629 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1630 err.span_label(trait_span, "item in trait");
1637 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1641 // Check for missing items from trait
1642 let mut missing_items = Vec::new();
1643 let mut invalidated_items = Vec::new();
1644 let associated_type_overridden = overridden_associated_type.is_some();
1645 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1646 let is_implemented = trait_def.ancestors(tcx, impl_id)
1647 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1649 .map(|node_item| !node_item.node.is_from_trait())
1652 if !is_implemented && !tcx.impl_is_default(impl_id) {
1653 if !trait_item.defaultness.has_value() {
1654 missing_items.push(trait_item);
1655 } else if associated_type_overridden {
1656 invalidated_items.push(trait_item.ident);
1661 if !missing_items.is_empty() {
1662 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1663 "not all trait items implemented, missing: `{}`",
1664 missing_items.iter()
1665 .map(|trait_item| trait_item.ident.to_string())
1666 .collect::<Vec<_>>().join("`, `"));
1667 err.span_label(impl_span, format!("missing `{}` in implementation",
1668 missing_items.iter()
1669 .map(|trait_item| trait_item.ident.to_string())
1670 .collect::<Vec<_>>().join("`, `")));
1671 for trait_item in missing_items {
1672 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1673 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1675 err.note_trait_signature(trait_item.ident.to_string(),
1676 trait_item.signature(&tcx));
1682 if !invalidated_items.is_empty() {
1683 let invalidator = overridden_associated_type.unwrap();
1684 span_err!(tcx.sess, invalidator.span, E0399,
1685 "the following trait items need to be reimplemented \
1686 as `{}` was overridden: `{}`",
1688 invalidated_items.iter()
1689 .map(|name| name.to_string())
1690 .collect::<Vec<_>>().join("`, `"))
1694 /// Checks whether a type can be represented in memory. In particular, it
1695 /// identifies types that contain themselves without indirection through a
1696 /// pointer, which would mean their size is unbounded.
1697 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1701 let rty = tcx.type_of(item_def_id);
1703 // Check that it is possible to represent this type. This call identifies
1704 // (1) types that contain themselves and (2) types that contain a different
1705 // recursive type. It is only necessary to throw an error on those that
1706 // contain themselves. For case 2, there must be an inner type that will be
1707 // caught by case 1.
1708 match rty.is_representable(tcx, sp) {
1709 Representability::SelfRecursive(spans) => {
1710 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1712 err.span_label(span, "recursive without indirection");
1717 Representability::Representable | Representability::ContainsRecursive => (),
1722 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1723 let t = tcx.type_of(def_id);
1724 if let ty::Adt(def, substs) = t.sty {
1725 if def.is_struct() {
1726 let fields = &def.non_enum_variant().fields;
1727 if fields.is_empty() {
1728 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1731 let e = fields[0].ty(tcx, substs);
1732 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1733 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1734 .span_label(sp, "SIMD elements must have the same type")
1739 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1740 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1742 span_err!(tcx.sess, sp, E0077,
1743 "SIMD vector element type should be machine type");
1751 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1752 let repr = tcx.adt_def(def_id).repr;
1754 for attr in tcx.get_attrs(def_id).iter() {
1755 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1756 if let attr::ReprPacked(pack) = r {
1757 if pack != repr.pack {
1758 struct_span_err!(tcx.sess, sp, E0634,
1759 "type has conflicting packed representation hints").emit();
1765 struct_span_err!(tcx.sess, sp, E0587,
1766 "type has conflicting packed and align representation hints").emit();
1768 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1769 struct_span_err!(tcx.sess, sp, E0588,
1770 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1775 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1777 stack: &mut Vec<DefId>) -> bool {
1778 let t = tcx.type_of(def_id);
1779 if stack.contains(&def_id) {
1780 debug!("check_packed_inner: {:?} is recursive", t);
1783 if let ty::Adt(def, substs) = t.sty {
1784 if def.is_struct() || def.is_union() {
1785 if tcx.adt_def(def.did).repr.align > 0 {
1788 // push struct def_id before checking fields
1790 for field in &def.non_enum_variant().fields {
1791 let f = field.ty(tcx, substs);
1792 if let ty::Adt(def, _) = f.sty {
1793 if check_packed_inner(tcx, def.did, stack) {
1798 // only need to pop if not early out
1805 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1806 let adt = tcx.adt_def(def_id);
1807 if !adt.repr.transparent() {
1811 // For each field, figure out if it's known to be a ZST and align(1)
1812 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1813 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1814 let param_env = tcx.param_env(field.did);
1815 let layout = tcx.layout_of(param_env.and(ty));
1816 // We are currently checking the type this field came from, so it must be local
1817 let span = tcx.hir().span_if_local(field.did).unwrap();
1818 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1819 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1823 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1824 let non_zst_count = non_zst_fields.clone().count();
1825 if non_zst_count != 1 {
1826 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1827 struct_span_err!(tcx.sess, sp, E0690,
1828 "transparent struct needs exactly one non-zero-sized field, but has {}",
1830 .span_note(field_spans, "non-zero-sized field")
1833 for (span, zst, align1) in field_infos {
1835 span_err!(tcx.sess, span, E0691,
1836 "zero-sized field in transparent struct has alignment larger than 1");
1841 #[allow(trivial_numeric_casts)]
1842 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1844 vs: &'tcx [hir::Variant],
1846 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1847 let def = tcx.adt_def(def_id);
1848 def.destructor(tcx); // force the destructor to be evaluated
1851 let attributes = tcx.get_attrs(def_id);
1852 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1854 tcx.sess, attr.span, E0084,
1855 "unsupported representation for zero-variant enum")
1856 .span_label(sp, "zero-variant enum")
1861 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1862 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1863 if !tcx.features().repr128 {
1864 emit_feature_err(&tcx.sess.parse_sess,
1867 GateIssue::Language,
1868 "repr with 128-bit type is unstable");
1873 if let Some(ref e) = v.node.disr_expr {
1874 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1878 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1879 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1880 // Check for duplicate discriminant values
1881 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1882 let variant_did = def.variants[VariantIdx::new(i)].did;
1883 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1884 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1885 let i_span = match variant_i.node.disr_expr {
1886 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1887 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1889 let span = match v.node.disr_expr {
1890 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1893 struct_span_err!(tcx.sess, span, E0081,
1894 "discriminant value `{}` already exists", disr_vals[i])
1895 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1896 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1899 disr_vals.push(discr);
1902 check_representable(tcx, sp, def_id);
1905 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1909 span_err!(tcx.sess, span, E0533,
1910 "expected unit struct/variant or constant, found {} `{}`",
1912 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1915 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1916 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1918 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1919 -> Lrc<ty::GenericPredicates<'tcx>>
1922 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1923 let item_id = tcx.hir().ty_param_owner(hir_id);
1924 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1925 let generics = tcx.generics_of(item_def_id);
1926 let index = generics.param_def_id_to_index[&def_id];
1927 Lrc::new(ty::GenericPredicates {
1929 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1931 ty::Predicate::Trait(ref data)
1932 if data.skip_binder().self_ty().is_param(index) => {
1933 // HACK(eddyb) should get the original `Span`.
1934 let span = tcx.def_span(def_id);
1935 Some((predicate, span))
1943 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1944 -> Option<ty::Region<'tcx>> {
1946 Some(def) => infer::EarlyBoundRegion(span, def.name),
1947 None => infer::MiscVariable(span)
1949 Some(self.next_region_var(v))
1952 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1953 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1956 fn ty_infer_for_def(&self,
1957 ty_param_def: &ty::GenericParamDef,
1958 span: Span) -> Ty<'tcx> {
1959 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1965 fn projected_ty_from_poly_trait_ref(&self,
1968 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1971 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1973 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1977 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1980 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1981 if ty.has_escaping_bound_vars() {
1982 ty // FIXME: normalization and escaping regions
1984 self.normalize_associated_types_in(span, &ty)
1988 fn set_tainted_by_errors(&self) {
1989 self.infcx.set_tainted_by_errors()
1992 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1993 self.write_ty(hir_id, ty)
1997 /// Controls whether the arguments are tupled. This is used for the call
2000 /// Tupling means that all call-side arguments are packed into a tuple and
2001 /// passed as a single parameter. For example, if tupling is enabled, this
2004 /// fn f(x: (isize, isize))
2006 /// Can be called as:
2013 #[derive(Clone, Eq, PartialEq)]
2014 enum TupleArgumentsFlag {
2019 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2020 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2021 param_env: ty::ParamEnv<'tcx>,
2022 body_id: hir::HirId)
2023 -> FnCtxt<'a, 'gcx, 'tcx> {
2027 err_count_on_creation: inh.tcx.sess.err_count(),
2029 ret_coercion_span: RefCell::new(None),
2031 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2032 hir::CRATE_HIR_ID)),
2033 diverges: Cell::new(Diverges::Maybe),
2034 has_errors: Cell::new(false),
2035 enclosing_breakables: RefCell::new(EnclosingBreakables {
2037 by_id: Default::default(),
2043 pub fn sess(&self) -> &Session {
2047 pub fn err_count_since_creation(&self) -> usize {
2048 self.tcx.sess.err_count() - self.err_count_on_creation
2051 /// Produces warning on the given node, if the current point in the
2052 /// function is unreachable, and there hasn't been another warning.
2053 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2054 if self.diverges.get() == Diverges::Always {
2055 self.diverges.set(Diverges::WarnedAlways);
2057 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2059 self.tcx().lint_hir(
2060 lint::builtin::UNREACHABLE_CODE,
2062 &format!("unreachable {}", kind));
2068 code: ObligationCauseCode<'tcx>)
2069 -> ObligationCause<'tcx> {
2070 ObligationCause::new(span, self.body_id, code)
2073 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2074 self.cause(span, ObligationCauseCode::MiscObligation)
2077 /// Resolves type variables in `ty` if possible. Unlike the infcx
2078 /// version (resolve_type_vars_if_possible), this version will
2079 /// also select obligations if it seems useful, in an effort
2080 /// to get more type information.
2081 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2082 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2084 // No Infer()? Nothing needs doing.
2085 if !ty.has_infer_types() {
2086 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2090 // If `ty` is a type variable, see whether we already know what it is.
2091 ty = self.resolve_type_vars_if_possible(&ty);
2092 if !ty.has_infer_types() {
2093 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2097 // If not, try resolving pending obligations as much as
2098 // possible. This can help substantially when there are
2099 // indirect dependencies that don't seem worth tracking
2101 self.select_obligations_where_possible(false);
2102 ty = self.resolve_type_vars_if_possible(&ty);
2104 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2108 fn record_deferred_call_resolution(&self,
2109 closure_def_id: DefId,
2110 r: DeferredCallResolution<'gcx, 'tcx>) {
2111 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2112 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2115 fn remove_deferred_call_resolutions(&self,
2116 closure_def_id: DefId)
2117 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2119 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2120 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2123 pub fn tag(&self) -> String {
2124 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2125 format!("{:?}", self_ptr)
2128 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2129 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2130 span_bug!(span, "no type for local variable {}",
2131 self.tcx.hir().hir_to_string(nid))
2136 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2137 debug!("write_ty({:?}, {:?}) in fcx {}",
2138 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2139 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2141 if ty.references_error() {
2142 self.has_errors.set(true);
2143 self.set_tainted_by_errors();
2147 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2148 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2151 pub fn write_method_call(&self,
2153 method: MethodCallee<'tcx>) {
2154 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2157 .type_dependent_defs_mut()
2158 .insert(hir_id, Def::Method(method.def_id));
2160 self.write_substs(hir_id, method.substs);
2162 // When the method is confirmed, the `method.substs` includes
2163 // parameters from not just the method, but also the impl of
2164 // the method -- in particular, the `Self` type will be fully
2165 // resolved. However, those are not something that the "user
2166 // specified" -- i.e., those types come from the inferred type
2167 // of the receiver, not something the user wrote. So when we
2168 // create the user-substs, we want to replace those earlier
2169 // types with just the types that the user actually wrote --
2170 // that is, those that appear on the *method itself*.
2172 // As an example, if the user wrote something like
2173 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2174 // type of `foo` (possibly adjusted), but we don't want to
2175 // include that. We want just the `[_, u32]` part.
2176 if !method.substs.is_noop() {
2177 let method_generics = self.tcx.generics_of(method.def_id);
2178 if !method_generics.params.is_empty() {
2179 let user_type_annotation = self.infcx.probe(|_| {
2180 let user_substs = UserSubsts {
2181 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2182 let i = param.index as usize;
2183 if i < method_generics.parent_count {
2184 self.infcx.var_for_def(DUMMY_SP, param)
2189 user_self_ty: None, // not relevant here
2192 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2198 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2199 self.write_user_type_annotation(hir_id, user_type_annotation);
2204 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2205 if !substs.is_noop() {
2206 debug!("write_substs({:?}, {:?}) in fcx {}",
2211 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2215 /// Given the substs that we just converted from the HIR, try to
2216 /// canonicalize them and store them as user-given substitutions
2217 /// (i.e., substitutions that must be respected by the NLL check).
2219 /// This should be invoked **before any unifications have
2220 /// occurred**, so that annotations like `Vec<_>` are preserved
2222 pub fn write_user_type_annotation_from_substs(
2226 substs: SubstsRef<'tcx>,
2227 user_self_ty: Option<UserSelfTy<'tcx>>,
2230 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2231 user_self_ty={:?} in fcx {}",
2232 hir_id, def_id, substs, user_self_ty, self.tag(),
2235 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2236 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2237 &UserType::TypeOf(def_id, UserSubsts {
2242 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2243 self.write_user_type_annotation(hir_id, canonicalized);
2247 pub fn write_user_type_annotation(
2250 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2253 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2254 hir_id, canonical_user_type_annotation, self.tag(),
2257 if !canonical_user_type_annotation.is_identity() {
2258 self.tables.borrow_mut().user_provided_types_mut().insert(
2259 hir_id, canonical_user_type_annotation
2262 debug!("write_user_type_annotation: skipping identity substs");
2266 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2267 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2273 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2274 Entry::Vacant(entry) => { entry.insert(adj); },
2275 Entry::Occupied(mut entry) => {
2276 debug!(" - composing on top of {:?}", entry.get());
2277 match (&entry.get()[..], &adj[..]) {
2278 // Applying any adjustment on top of a NeverToAny
2279 // is a valid NeverToAny adjustment, because it can't
2281 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2283 Adjustment { kind: Adjust::Deref(_), .. },
2284 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2286 Adjustment { kind: Adjust::Deref(_), .. },
2287 .. // Any following adjustments are allowed.
2289 // A reborrow has no effect before a dereference.
2291 // FIXME: currently we never try to compose autoderefs
2292 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2294 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2295 expr, entry.get(), adj)
2297 *entry.get_mut() = adj;
2302 /// Basically whenever we are converting from a type scheme into
2303 /// the fn body space, we always want to normalize associated
2304 /// types as well. This function combines the two.
2305 fn instantiate_type_scheme<T>(&self,
2307 substs: SubstsRef<'tcx>,
2310 where T : TypeFoldable<'tcx>
2312 let value = value.subst(self.tcx, substs);
2313 let result = self.normalize_associated_types_in(span, &value);
2314 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2321 /// As `instantiate_type_scheme`, but for the bounds found in a
2322 /// generic type scheme.
2323 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2324 -> ty::InstantiatedPredicates<'tcx> {
2325 let bounds = self.tcx.predicates_of(def_id);
2326 let result = bounds.instantiate(self.tcx, substs);
2327 let result = self.normalize_associated_types_in(span, &result);
2328 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2335 /// Replaces the opaque types from the given value with type variables,
2336 /// and records the `OpaqueTypeMap` for later use during writeback. See
2337 /// `InferCtxt::instantiate_opaque_types` for more details.
2338 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2340 parent_id: hir::HirId,
2343 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2344 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2348 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2349 self.instantiate_opaque_types(
2357 let mut opaque_types = self.opaque_types.borrow_mut();
2358 for (ty, decl) in opaque_type_map {
2359 let old_value = opaque_types.insert(ty, decl);
2360 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2366 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2367 where T : TypeFoldable<'tcx>
2369 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2372 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2374 where T : TypeFoldable<'tcx>
2376 self.inh.partially_normalize_associated_types_in(span,
2382 pub fn require_type_meets(&self,
2385 code: traits::ObligationCauseCode<'tcx>,
2388 self.register_bound(
2391 traits::ObligationCause::new(span, self.body_id, code));
2394 pub fn require_type_is_sized(&self,
2397 code: traits::ObligationCauseCode<'tcx>)
2399 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2400 self.require_type_meets(ty, span, code, lang_item);
2403 pub fn require_type_is_sized_deferred(&self,
2406 code: traits::ObligationCauseCode<'tcx>)
2408 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2411 pub fn register_bound(&self,
2414 cause: traits::ObligationCause<'tcx>)
2416 self.fulfillment_cx.borrow_mut()
2417 .register_bound(self, self.param_env, ty, def_id, cause);
2420 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2421 let t = AstConv::ast_ty_to_ty(self, ast_t);
2422 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2426 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2427 let ty = self.to_ty(ast_ty);
2428 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2430 if Self::can_contain_user_lifetime_bounds(ty) {
2431 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2432 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2433 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2439 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::LazyConst<'tcx> {
2440 AstConv::ast_const_to_const(self, ast_c, ty)
2443 // If the type given by the user has free regions, save it for later, since
2444 // NLL would like to enforce those. Also pass in types that involve
2445 // projections, since those can resolve to `'static` bounds (modulo #54940,
2446 // which hopefully will be fixed by the time you see this comment, dear
2447 // reader, although I have my doubts). Also pass in types with inference
2448 // types, because they may be repeated. Other sorts of things are already
2449 // sufficiently enforced with erased regions. =)
2450 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2452 T: TypeFoldable<'tcx>
2454 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2457 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2458 match self.tables.borrow().node_types().get(id) {
2460 None if self.is_tainted_by_errors() => self.tcx.types.err,
2462 let node_id = self.tcx.hir().hir_to_node_id(id);
2463 bug!("no type for node {}: {} in fcx {}",
2464 node_id, self.tcx.hir().node_to_string(node_id),
2470 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2471 /// outlive the region `r`.
2472 pub fn register_wf_obligation(&self,
2475 code: traits::ObligationCauseCode<'tcx>)
2477 // WF obligations never themselves fail, so no real need to give a detailed cause:
2478 let cause = traits::ObligationCause::new(span, self.body_id, code);
2479 self.register_predicate(traits::Obligation::new(cause,
2481 ty::Predicate::WellFormed(ty)));
2484 /// Registers obligations that all types appearing in `substs` are well-formed.
2485 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2486 for ty in substs.types() {
2487 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2491 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2492 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2493 /// trait/region obligations.
2495 /// For example, if there is a function:
2498 /// fn foo<'a,T:'a>(...)
2501 /// and a reference:
2507 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2508 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2509 pub fn add_obligations_for_parameters(&self,
2510 cause: traits::ObligationCause<'tcx>,
2511 predicates: &ty::InstantiatedPredicates<'tcx>)
2513 assert!(!predicates.has_escaping_bound_vars());
2515 debug!("add_obligations_for_parameters(predicates={:?})",
2518 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2519 self.register_predicate(obligation);
2523 // FIXME(arielb1): use this instead of field.ty everywhere
2524 // Only for fields! Returns <none> for methods>
2525 // Indifferent to privacy flags
2526 pub fn field_ty(&self,
2528 field: &'tcx ty::FieldDef,
2529 substs: SubstsRef<'tcx>)
2532 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2535 fn check_casts(&self) {
2536 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2537 for cast in deferred_cast_checks.drain(..) {
2542 fn resolve_generator_interiors(&self, def_id: DefId) {
2543 let mut generators = self.deferred_generator_interiors.borrow_mut();
2544 for (body_id, interior) in generators.drain(..) {
2545 self.select_obligations_where_possible(false);
2546 generator_interior::resolve_interior(self, def_id, body_id, interior);
2550 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2551 // Non-numerics get replaced with ! or () (depending on whether
2552 // feature(never_type) is enabled, unconstrained ints with i32,
2553 // unconstrained floats with f64.
2554 // Fallback becomes very dubious if we have encountered type-checking errors.
2555 // In that case, fallback to Error.
2556 // The return value indicates whether fallback has occurred.
2557 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2558 use rustc::ty::error::UnconstrainedNumeric::Neither;
2559 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2561 assert!(ty.is_ty_infer());
2562 let fallback = match self.type_is_unconstrained_numeric(ty) {
2563 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2564 UnconstrainedInt => self.tcx.types.i32,
2565 UnconstrainedFloat => self.tcx.types.f64,
2566 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2567 Neither => return false,
2569 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2570 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2574 fn select_all_obligations_or_error(&self) {
2575 debug!("select_all_obligations_or_error");
2576 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2577 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2581 /// Select as many obligations as we can at present.
2582 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2583 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2584 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2588 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2589 /// returns a type of `&T`, but the actual type we assign to the
2590 /// *expression* is `T`. So this function just peels off the return
2591 /// type by one layer to yield `T`.
2592 fn make_overloaded_place_return_type(&self,
2593 method: MethodCallee<'tcx>)
2594 -> ty::TypeAndMut<'tcx>
2596 // extract method return type, which will be &T;
2597 let ret_ty = method.sig.output();
2599 // method returns &T, but the type as visible to user is T, so deref
2600 ret_ty.builtin_deref(true).unwrap()
2603 fn lookup_indexing(&self,
2605 base_expr: &'gcx hir::Expr,
2609 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2611 // FIXME(#18741) -- this is almost but not quite the same as the
2612 // autoderef that normal method probing does. They could likely be
2615 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2616 let mut result = None;
2617 while result.is_none() && autoderef.next().is_some() {
2618 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2620 autoderef.finalize(self);
2624 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2625 /// (and otherwise adjust) `base_expr`, looking for a type which either
2626 /// supports builtin indexing or overloaded indexing.
2627 /// This loop implements one step in that search; the autoderef loop
2628 /// is implemented by `lookup_indexing`.
2629 fn try_index_step(&self,
2631 base_expr: &hir::Expr,
2632 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2635 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2637 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2638 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2645 for &unsize in &[false, true] {
2646 let mut self_ty = adjusted_ty;
2648 // We only unsize arrays here.
2649 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2650 self_ty = self.tcx.mk_slice(element_ty);
2656 // If some lookup succeeds, write callee into table and extract index/element
2657 // type from the method signature.
2658 // If some lookup succeeded, install method in table
2659 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2660 let method = self.try_overloaded_place_op(
2661 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2663 let result = method.map(|ok| {
2664 debug!("try_index_step: success, using overloaded indexing");
2665 let method = self.register_infer_ok_obligations(ok);
2667 let mut adjustments = autoderef.adjust_steps(self, needs);
2668 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2669 let mutbl = match r_mutbl {
2670 hir::MutImmutable => AutoBorrowMutability::Immutable,
2671 hir::MutMutable => AutoBorrowMutability::Mutable {
2672 // Indexing can be desugared to a method call,
2673 // so maybe we could use two-phase here.
2674 // See the documentation of AllowTwoPhase for why that's
2675 // not the case today.
2676 allow_two_phase_borrow: AllowTwoPhase::No,
2679 adjustments.push(Adjustment {
2680 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2681 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2688 adjustments.push(Adjustment {
2689 kind: Adjust::Unsize,
2690 target: method.sig.inputs()[0]
2693 self.apply_adjustments(base_expr, adjustments);
2695 self.write_method_call(expr.hir_id, method);
2696 (input_ty, self.make_overloaded_place_return_type(method).ty)
2698 if result.is_some() {
2706 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2707 let (tr, name) = match (op, is_mut) {
2708 (PlaceOp::Deref, false) =>
2709 (self.tcx.lang_items().deref_trait(), "deref"),
2710 (PlaceOp::Deref, true) =>
2711 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2712 (PlaceOp::Index, false) =>
2713 (self.tcx.lang_items().index_trait(), "index"),
2714 (PlaceOp::Index, true) =>
2715 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2717 (tr, ast::Ident::from_str(name))
2720 fn try_overloaded_place_op(&self,
2723 arg_tys: &[Ty<'tcx>],
2726 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2728 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2734 // Try Mut first, if needed.
2735 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2736 let method = match (needs, mut_tr) {
2737 (Needs::MutPlace, Some(trait_did)) => {
2738 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2743 // Otherwise, fall back to the immutable version.
2744 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2745 let method = match (method, imm_tr) {
2746 (None, Some(trait_did)) => {
2747 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2749 (method, _) => method,
2755 fn check_method_argument_types(&self,
2758 method: Result<MethodCallee<'tcx>, ()>,
2759 args_no_rcvr: &'gcx [hir::Expr],
2760 tuple_arguments: TupleArgumentsFlag,
2761 expected: Expectation<'tcx>)
2763 let has_error = match method {
2765 method.substs.references_error() || method.sig.references_error()
2770 let err_inputs = self.err_args(args_no_rcvr.len());
2772 let err_inputs = match tuple_arguments {
2773 DontTupleArguments => err_inputs,
2774 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2777 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2778 false, tuple_arguments, None);
2779 return self.tcx.types.err;
2782 let method = method.unwrap();
2783 // HACK(eddyb) ignore self in the definition (see above).
2784 let expected_arg_tys = self.expected_inputs_for_expected_output(
2787 method.sig.output(),
2788 &method.sig.inputs()[1..]
2790 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2791 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2792 self.tcx.hir().span_if_local(method.def_id));
2796 fn self_type_matches_expected_vid(
2798 trait_ref: ty::PolyTraitRef<'tcx>,
2799 expected_vid: ty::TyVid,
2801 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2803 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2804 trait_ref, self_ty, expected_vid
2807 ty::Infer(ty::TyVar(found_vid)) => {
2808 // FIXME: consider using `sub_root_var` here so we
2809 // can see through subtyping.
2810 let found_vid = self.root_var(found_vid);
2811 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2812 expected_vid == found_vid
2818 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2819 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2820 + Captures<'gcx> + 'b
2822 // FIXME: consider using `sub_root_var` here so we
2823 // can see through subtyping.
2824 let ty_var_root = self.root_var(self_ty);
2825 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2826 self_ty, ty_var_root,
2827 self.fulfillment_cx.borrow().pending_obligations());
2831 .pending_obligations()
2833 .filter_map(move |obligation| match obligation.predicate {
2834 ty::Predicate::Projection(ref data) =>
2835 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2836 ty::Predicate::Trait(ref data) =>
2837 Some((data.to_poly_trait_ref(), obligation)),
2838 ty::Predicate::Subtype(..) => None,
2839 ty::Predicate::RegionOutlives(..) => None,
2840 ty::Predicate::TypeOutlives(..) => None,
2841 ty::Predicate::WellFormed(..) => None,
2842 ty::Predicate::ObjectSafe(..) => None,
2843 ty::Predicate::ConstEvaluatable(..) => None,
2844 // N.B., this predicate is created by breaking down a
2845 // `ClosureType: FnFoo()` predicate, where
2846 // `ClosureType` represents some `Closure`. It can't
2847 // possibly be referring to the current closure,
2848 // because we haven't produced the `Closure` for
2849 // this closure yet; this is exactly why the other
2850 // code is looking for a self type of a unresolved
2851 // inference variable.
2852 ty::Predicate::ClosureKind(..) => None,
2853 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2856 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2857 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2858 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2862 /// Generic function that factors out common logic from function calls,
2863 /// method calls and overloaded operators.
2864 fn check_argument_types(&self,
2867 fn_inputs: &[Ty<'tcx>],
2868 mut expected_arg_tys: &[Ty<'tcx>],
2869 args: &'gcx [hir::Expr],
2871 tuple_arguments: TupleArgumentsFlag,
2872 def_span: Option<Span>) {
2875 // Grab the argument types, supplying fresh type variables
2876 // if the wrong number of arguments were supplied
2877 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2883 // All the input types from the fn signature must outlive the call
2884 // so as to validate implied bounds.
2885 for &fn_input_ty in fn_inputs {
2886 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2889 let expected_arg_count = fn_inputs.len();
2891 let param_count_error = |expected_count: usize,
2896 let mut err = tcx.sess.struct_span_err_with_code(sp,
2897 &format!("this function takes {}{} but {} {} supplied",
2898 if c_variadic { "at least " } else { "" },
2899 potentially_plural_count(expected_count, "parameter"),
2900 potentially_plural_count(arg_count, "parameter"),
2901 if arg_count == 1 {"was"} else {"were"}),
2902 DiagnosticId::Error(error_code.to_owned()));
2904 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2905 err.span_label(def_s, "defined here");
2908 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2909 // remove closing `)` from the span
2910 let sugg_span = sugg_span.shrink_to_lo();
2911 err.span_suggestion(
2913 "expected the unit value `()`; create it with empty parentheses",
2915 Applicability::MachineApplicable);
2917 err.span_label(sp, format!("expected {}{}",
2918 if c_variadic { "at least " } else { "" },
2919 potentially_plural_count(expected_count, "parameter")));
2924 let formal_tys = if tuple_arguments == TupleArguments {
2925 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2926 match tuple_type.sty {
2927 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2928 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2929 expected_arg_tys = &[];
2930 self.err_args(args.len())
2932 ty::Tuple(arg_types) => {
2933 expected_arg_tys = match expected_arg_tys.get(0) {
2934 Some(&ty) => match ty.sty {
2935 ty::Tuple(ref tys) => &tys,
2943 span_err!(tcx.sess, sp, E0059,
2944 "cannot use call notation; the first type parameter \
2945 for the function trait is neither a tuple nor unit");
2946 expected_arg_tys = &[];
2947 self.err_args(args.len())
2950 } else if expected_arg_count == supplied_arg_count {
2952 } else if c_variadic {
2953 if supplied_arg_count >= expected_arg_count {
2956 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2957 expected_arg_tys = &[];
2958 self.err_args(supplied_arg_count)
2961 // is the missing argument of type `()`?
2962 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2963 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2964 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2965 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2969 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2971 expected_arg_tys = &[];
2972 self.err_args(supplied_arg_count)
2974 // If there is no expectation, expect formal_tys.
2975 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2981 debug!("check_argument_types: formal_tys={:?}",
2982 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2984 // Check the arguments.
2985 // We do this in a pretty awful way: first we type-check any arguments
2986 // that are not closures, then we type-check the closures. This is so
2987 // that we have more information about the types of arguments when we
2988 // type-check the functions. This isn't really the right way to do this.
2989 for &check_closures in &[false, true] {
2990 debug!("check_closures={}", check_closures);
2992 // More awful hacks: before we check argument types, try to do
2993 // an "opportunistic" vtable resolution of any trait bounds on
2994 // the call. This helps coercions.
2996 self.select_obligations_where_possible(false);
2999 // For C-variadic functions, we don't have a declared type for all of
3000 // the arguments hence we only do our usual type checking with
3001 // the arguments who's types we do know.
3002 let t = if c_variadic {
3004 } else if tuple_arguments == TupleArguments {
3009 for (i, arg) in args.iter().take(t).enumerate() {
3010 // Warn only for the first loop (the "no closures" one).
3011 // Closure arguments themselves can't be diverging, but
3012 // a previous argument can, e.g., `foo(panic!(), || {})`.
3013 if !check_closures {
3014 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3017 let is_closure = match arg.node {
3018 ExprKind::Closure(..) => true,
3022 if is_closure != check_closures {
3026 debug!("checking the argument");
3027 let formal_ty = formal_tys[i];
3029 // The special-cased logic below has three functions:
3030 // 1. Provide as good of an expected type as possible.
3031 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3033 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3035 // 2. Coerce to the most detailed type that could be coerced
3036 // to, which is `expected_ty` if `rvalue_hint` returns an
3037 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3038 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3039 // We're processing function arguments so we definitely want to use
3040 // two-phase borrows.
3041 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3043 // 3. Relate the expected type and the formal one,
3044 // if the expected type was used for the coercion.
3045 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3049 // We also need to make sure we at least write the ty of the other
3050 // arguments which we skipped above.
3052 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3053 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3054 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3057 for arg in args.iter().skip(expected_arg_count) {
3058 let arg_ty = self.check_expr(&arg);
3060 // There are a few types which get autopromoted when passed via varargs
3061 // in C but we just error out instead and require explicit casts.
3062 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3064 ty::Float(ast::FloatTy::F32) => {
3065 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3067 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3068 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3070 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3071 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3074 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3075 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3076 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3084 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3085 vec![self.tcx.types.err; len]
3088 // AST fragment checking
3091 expected: Expectation<'tcx>)
3097 ast::LitKind::Str(..) => tcx.mk_static_str(),
3098 ast::LitKind::ByteStr(ref v) => {
3099 tcx.mk_imm_ref(tcx.types.re_static,
3100 tcx.mk_array(tcx.types.u8, v.len() as u64))
3102 ast::LitKind::Byte(_) => tcx.types.u8,
3103 ast::LitKind::Char(_) => tcx.types.char,
3104 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3105 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3106 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3107 let opt_ty = expected.to_option(self).and_then(|ty| {
3109 ty::Int(_) | ty::Uint(_) => Some(ty),
3110 ty::Char => Some(tcx.types.u8),
3111 ty::RawPtr(..) => Some(tcx.types.usize),
3112 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3116 opt_ty.unwrap_or_else(
3117 || tcx.mk_int_var(self.next_int_var_id()))
3119 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3120 ast::LitKind::FloatUnsuffixed(_) => {
3121 let opt_ty = expected.to_option(self).and_then(|ty| {
3123 ty::Float(_) => Some(ty),
3127 opt_ty.unwrap_or_else(
3128 || tcx.mk_float_var(self.next_float_var_id()))
3130 ast::LitKind::Bool(_) => tcx.types.bool,
3131 ast::LitKind::Err(_) => tcx.types.err,
3135 fn check_expr_eq_type(&self,
3136 expr: &'gcx hir::Expr,
3137 expected: Ty<'tcx>) {
3138 let ty = self.check_expr_with_hint(expr, expected);
3139 self.demand_eqtype(expr.span, expected, ty);
3142 pub fn check_expr_has_type_or_error(&self,
3143 expr: &'gcx hir::Expr,
3144 expected: Ty<'tcx>) -> Ty<'tcx> {
3145 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3148 fn check_expr_meets_expectation_or_error(&self,
3149 expr: &'gcx hir::Expr,
3150 expected: Expectation<'tcx>) -> Ty<'tcx> {
3151 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3152 let mut ty = self.check_expr_with_expectation(expr, expected);
3154 // While we don't allow *arbitrary* coercions here, we *do* allow
3155 // coercions from ! to `expected`.
3157 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3158 "expression with never type wound up being adjusted");
3159 let adj_ty = self.next_diverging_ty_var(
3160 TypeVariableOrigin::AdjustmentType(expr.span));
3161 self.apply_adjustments(expr, vec![Adjustment {
3162 kind: Adjust::NeverToAny,
3168 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3169 // Add help to type error if this is an `if` condition with an assignment.
3170 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3171 = (expected, &expr.node)
3173 let msg = "try comparing for equality";
3174 if let (Ok(left), Ok(right)) = (
3175 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3176 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3178 err.span_suggestion(
3181 format!("{} == {}", left, right),
3182 Applicability::MaybeIncorrect);
3192 fn check_expr_coercable_to_type(&self,
3193 expr: &'gcx hir::Expr,
3194 expected: Ty<'tcx>) -> Ty<'tcx> {
3195 let ty = self.check_expr_with_hint(expr, expected);
3196 // checks don't need two phase
3197 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3200 fn check_expr_with_hint(&self,
3201 expr: &'gcx hir::Expr,
3202 expected: Ty<'tcx>) -> Ty<'tcx> {
3203 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3206 fn check_expr_with_expectation(&self,
3207 expr: &'gcx hir::Expr,
3208 expected: Expectation<'tcx>) -> Ty<'tcx> {
3209 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3212 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3213 self.check_expr_with_expectation(expr, NoExpectation)
3216 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3217 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3220 // Determine the `Self` type, using fresh variables for all variables
3221 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3222 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3224 pub fn impl_self_ty(&self,
3225 span: Span, // (potential) receiver for this impl
3227 -> TypeAndSubsts<'tcx> {
3228 let ity = self.tcx.type_of(did);
3229 debug!("impl_self_ty: ity={:?}", ity);
3231 let substs = self.fresh_substs_for_item(span, did);
3232 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3234 TypeAndSubsts { substs: substs, ty: substd_ty }
3237 /// Unifies the output type with the expected type early, for more coercions
3238 /// and forward type information on the input expressions.
3239 fn expected_inputs_for_expected_output(&self,
3241 expected_ret: Expectation<'tcx>,
3242 formal_ret: Ty<'tcx>,
3243 formal_args: &[Ty<'tcx>])
3245 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3246 let ret_ty = match expected_ret.only_has_type(self) {
3248 None => return Vec::new()
3250 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3251 // Attempt to apply a subtyping relationship between the formal
3252 // return type (likely containing type variables if the function
3253 // is polymorphic) and the expected return type.
3254 // No argument expectations are produced if unification fails.
3255 let origin = self.misc(call_span);
3256 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3258 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3259 // to identity so the resulting type is not constrained.
3262 // Process any obligations locally as much as
3263 // we can. We don't care if some things turn
3264 // out unconstrained or ambiguous, as we're
3265 // just trying to get hints here.
3266 self.save_and_restore_in_snapshot_flag(|_| {
3267 let mut fulfill = TraitEngine::new(self.tcx);
3268 for obligation in ok.obligations {
3269 fulfill.register_predicate_obligation(self, obligation);
3271 fulfill.select_where_possible(self)
3272 }).map_err(|_| ())?;
3274 Err(_) => return Err(()),
3277 // Record all the argument types, with the substitutions
3278 // produced from the above subtyping unification.
3279 Ok(formal_args.iter().map(|ty| {
3280 self.resolve_type_vars_if_possible(ty)
3282 }).unwrap_or_default();
3283 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3284 formal_args, formal_ret,
3285 expect_args, expected_ret);
3289 // Checks a method call.
3290 fn check_method_call(&self,
3291 expr: &'gcx hir::Expr,
3292 segment: &hir::PathSegment,
3294 args: &'gcx [hir::Expr],
3295 expected: Expectation<'tcx>,
3296 needs: Needs) -> Ty<'tcx> {
3297 let rcvr = &args[0];
3298 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3299 // no need to check for bot/err -- callee does that
3300 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3302 let method = match self.lookup_method(rcvr_t,
3308 self.write_method_call(expr.hir_id, method);
3312 if segment.ident.name != keywords::Invalid.name() {
3313 self.report_method_error(span,
3316 SelfSource::MethodCall(rcvr),
3324 // Call the generic checker.
3325 self.check_method_argument_types(span,
3333 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3337 .unwrap_or_else(|| span_bug!(return_expr.span,
3338 "check_return_expr called outside fn body"));
3340 let ret_ty = ret_coercion.borrow().expected_ty();
3341 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3342 ret_coercion.borrow_mut()
3344 &self.cause(return_expr.span,
3345 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3350 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3351 // or 'if-else' expression.
3352 fn check_then_else(&self,
3353 cond_expr: &'gcx hir::Expr,
3354 then_expr: &'gcx hir::Expr,
3355 opt_else_expr: Option<&'gcx hir::Expr>,
3357 expected: Expectation<'tcx>) -> Ty<'tcx> {
3358 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3359 let cond_diverges = self.diverges.get();
3360 self.diverges.set(Diverges::Maybe);
3362 let expected = expected.adjust_for_branches(self);
3363 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3364 let then_diverges = self.diverges.get();
3365 self.diverges.set(Diverges::Maybe);
3367 // We've already taken the expected type's preferences
3368 // into account when typing the `then` branch. To figure
3369 // out the initial shot at a LUB, we thus only consider
3370 // `expected` if it represents a *hard* constraint
3371 // (`only_has_type`); otherwise, we just go with a
3372 // fresh type variable.
3373 let coerce_to_ty = expected.coercion_target_type(self, sp);
3374 let mut coerce: DynamicCoerceMany<'_, '_> = CoerceMany::new(coerce_to_ty);
3376 coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
3378 if let Some(else_expr) = opt_else_expr {
3379 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3380 let else_diverges = self.diverges.get();
3382 let mut outer_sp = if self.tcx.sess.source_map().is_multiline(sp) {
3383 // The `if`/`else` isn't in one line in the output, include some context to make it
3384 // clear it is an if/else expression:
3386 // LL | let x = if true {
3389 // || ----- expected because of this
3392 // || ^^^^^ expected i32, found u32
3394 // ||_____- if and else have incompatible types
3398 // The entire expression is in one line, only point at the arms
3400 // LL | let x = if true { 10i32 } else { 10u32 };
3401 // | ----- ^^^^^ expected i32, found u32
3403 // | expected because of this
3407 let mut remove_semicolon = None;
3408 let error_sp = if let ExprKind::Block(block, _) = &else_expr.node {
3409 if let Some(expr) = &block.expr {
3411 } else if let Some(stmt) = block.stmts.last() {
3412 // possibly incorrect trailing `;` in the else arm
3413 remove_semicolon = self.could_remove_semicolon(block, then_ty);
3415 } else { // empty block, point at its entirety
3416 // Avoid overlapping spans that aren't as readable:
3418 // 2 | let x = if true {
3421 // | | - expected because of this
3428 // | |______if and else have incompatible types
3429 // | expected integer, found ()
3431 // by not pointing at the entire expression:
3433 // 2 | let x = if true {
3434 // | ------- if and else have incompatible types
3436 // | - expected because of this
3441 // | |_____^ expected integer, found ()
3443 if outer_sp.is_some() {
3444 outer_sp = Some(self.tcx.sess.source_map().def_span(sp));
3448 } else { // shouldn't happen unless the parser has done something weird
3451 let then_sp = if let ExprKind::Block(block, _) = &then_expr.node {
3452 if let Some(expr) = &block.expr {
3454 } else if let Some(stmt) = block.stmts.last() {
3455 // possibly incorrect trailing `;` in the else arm
3456 remove_semicolon = remove_semicolon.or(
3457 self.could_remove_semicolon(block, else_ty));
3459 } else { // empty block, point at its entirety
3460 outer_sp = None; // same as in `error_sp`, cleanup output
3463 } else { // shouldn't happen unless the parser has done something weird
3467 let if_cause = self.cause(error_sp, ObligationCauseCode::IfExpression {
3470 semicolon: remove_semicolon,
3473 coerce.coerce(self, &if_cause, else_expr, else_ty);
3475 // We won't diverge unless both branches do (or the condition does).
3476 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3478 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3479 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3481 // If the condition is false we can't diverge.
3482 self.diverges.set(cond_diverges);
3485 let result_ty = coerce.complete(self);
3486 if cond_ty.references_error() {
3493 // Check field access expressions
3494 fn check_field(&self,
3495 expr: &'gcx hir::Expr,
3497 base: &'gcx hir::Expr,
3498 field: ast::Ident) -> Ty<'tcx> {
3499 let expr_t = self.check_expr_with_needs(base, needs);
3500 let expr_t = self.structurally_resolved_type(base.span,
3502 let mut private_candidate = None;
3503 let mut autoderef = self.autoderef(expr.span, expr_t);
3504 while let Some((base_t, _)) = autoderef.next() {
3506 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3507 debug!("struct named {:?}", base_t);
3508 let (ident, def_scope) =
3509 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3510 let fields = &base_def.non_enum_variant().fields;
3511 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3512 let field = &fields[index];
3513 let field_ty = self.field_ty(expr.span, field, substs);
3514 // Save the index of all fields regardless of their visibility in case
3515 // of error recovery.
3516 self.write_field_index(expr.hir_id, index);
3517 if field.vis.is_accessible_from(def_scope, self.tcx) {
3518 let adjustments = autoderef.adjust_steps(self, needs);
3519 self.apply_adjustments(base, adjustments);
3520 autoderef.finalize(self);
3522 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3525 private_candidate = Some((base_def.did, field_ty));
3528 ty::Tuple(ref tys) => {
3529 let fstr = field.as_str();
3530 if let Ok(index) = fstr.parse::<usize>() {
3531 if fstr == index.to_string() {
3532 if let Some(field_ty) = tys.get(index) {
3533 let adjustments = autoderef.adjust_steps(self, needs);
3534 self.apply_adjustments(base, adjustments);
3535 autoderef.finalize(self);
3537 self.write_field_index(expr.hir_id, index);
3546 autoderef.unambiguous_final_ty(self);
3548 if let Some((did, field_ty)) = private_candidate {
3549 let struct_path = self.tcx().item_path_str(did);
3550 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3551 "field `{}` of struct `{}` is private",
3552 field, struct_path);
3553 // Also check if an accessible method exists, which is often what is meant.
3554 if self.method_exists(field, expr_t, expr.hir_id, false)
3555 && !self.expr_in_place(expr.hir_id)
3557 self.suggest_method_call(
3559 &format!("a method `{}` also exists, call it with parentheses", field),
3567 } else if field.name == keywords::Invalid.name() {
3568 self.tcx().types.err
3569 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3570 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3571 "attempted to take value of method `{}` on type `{}`",
3574 if !self.expr_in_place(expr.hir_id) {
3575 self.suggest_method_call(
3577 "use parentheses to call the method",
3583 err.help("methods are immutable and cannot be assigned to");
3587 self.tcx().types.err
3589 if !expr_t.is_primitive_ty() {
3590 let mut err = self.no_such_field_err(field.span, field, expr_t);
3593 ty::Adt(def, _) if !def.is_enum() => {
3594 if let Some(suggested_field_name) =
3595 Self::suggest_field_name(def.non_enum_variant(),
3596 &field.as_str(), vec![]) {
3597 err.span_suggestion(
3599 "a field with a similar name exists",
3600 suggested_field_name.to_string(),
3601 Applicability::MaybeIncorrect,
3604 err.span_label(field.span, "unknown field");
3605 let struct_variant_def = def.non_enum_variant();
3606 let field_names = self.available_field_names(struct_variant_def);
3607 if !field_names.is_empty() {
3608 err.note(&format!("available fields are: {}",
3609 self.name_series_display(field_names)));
3613 ty::Array(_, len) => {
3614 if let (Some(len), Ok(user_index)) = (
3615 len.assert_usize(self.tcx),
3616 field.as_str().parse::<u64>()
3618 let base = self.tcx.sess.source_map()
3619 .span_to_snippet(base.span)
3621 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3622 let help = "instead of using tuple indexing, use array indexing";
3623 let suggestion = format!("{}[{}]", base, field);
3624 let applicability = if len < user_index {
3625 Applicability::MachineApplicable
3627 Applicability::MaybeIncorrect
3629 err.span_suggestion(
3630 expr.span, help, suggestion, applicability
3635 let base = self.tcx.sess.source_map()
3636 .span_to_snippet(base.span)
3637 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3638 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3639 let suggestion = format!("(*{}).{}", base, field);
3640 err.span_suggestion(
3644 Applicability::MaybeIncorrect,
3651 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3652 "`{}` is a primitive type and therefore doesn't have fields",
3655 self.tcx().types.err
3659 // Return an hint about the closest match in field names
3660 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3662 skip: Vec<LocalInternedString>)
3664 let names = variant.fields.iter().filter_map(|field| {
3665 // ignore already set fields and private fields from non-local crates
3666 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3667 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3670 Some(&field.ident.name)
3674 find_best_match_for_name(names, field, None)
3677 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3678 variant.fields.iter().filter(|field| {
3679 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3680 field.vis.is_accessible_from(def_scope, self.tcx)
3682 .map(|field| field.ident.name)
3686 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3687 // dynamic limit, to never omit just one field
3688 let limit = if names.len() == 6 { 6 } else { 5 };
3689 let mut display = names.iter().take(limit)
3690 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3691 if names.len() > limit {
3692 display = format!("{} ... and {} others", display, names.len() - limit);
3697 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3698 -> DiagnosticBuilder<'_> {
3699 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3700 "no field `{}` on type `{}`",
3704 fn report_unknown_field(&self,
3706 variant: &'tcx ty::VariantDef,
3708 skip_fields: &[hir::Field],
3710 let mut err = self.type_error_struct_with_diag(
3712 |actual| match ty.sty {
3713 ty::Adt(adt, ..) if adt.is_enum() => {
3714 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3715 "{} `{}::{}` has no field named `{}`",
3716 kind_name, actual, variant.ident, field.ident)
3719 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3720 "{} `{}` has no field named `{}`",
3721 kind_name, actual, field.ident)
3725 // prevent all specified fields from being suggested
3726 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3727 if let Some(field_name) = Self::suggest_field_name(variant,
3728 &field.ident.as_str(),
3729 skip_fields.collect()) {
3730 err.span_suggestion(
3732 "a field with a similar name exists",
3733 field_name.to_string(),
3734 Applicability::MaybeIncorrect,
3738 ty::Adt(adt, ..) => {
3740 err.span_label(field.ident.span,
3741 format!("`{}::{}` does not have this field",
3742 ty, variant.ident));
3744 err.span_label(field.ident.span,
3745 format!("`{}` does not have this field", ty));
3747 let available_field_names = self.available_field_names(variant);
3748 if !available_field_names.is_empty() {
3749 err.note(&format!("available fields are: {}",
3750 self.name_series_display(available_field_names)));
3753 _ => bug!("non-ADT passed to report_unknown_field")
3759 fn check_expr_struct_fields(&self,
3761 expected: Expectation<'tcx>,
3762 expr_id: hir::HirId,
3764 variant: &'tcx ty::VariantDef,
3765 ast_fields: &'gcx [hir::Field],
3766 check_completeness: bool) -> bool {
3770 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3771 .get(0).cloned().unwrap_or(adt_ty);
3772 // re-link the regions that EIfEO can erase.
3773 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3775 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3776 &ty::Adt(adt, substs) => {
3777 (substs, adt.adt_kind(), adt.variant_descr())
3779 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3782 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3783 (field.ident.modern(), (i, field))
3784 ).collect::<FxHashMap<_, _>>();
3786 let mut seen_fields = FxHashMap::default();
3788 let mut error_happened = false;
3790 // Type-check each field.
3791 for field in ast_fields {
3792 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3793 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3794 seen_fields.insert(ident, field.span);
3795 self.write_field_index(field.hir_id, i);
3797 // We don't look at stability attributes on
3798 // struct-like enums (yet...), but it's definitely not
3799 // a bug to have constructed one.
3800 if adt_kind != AdtKind::Enum {
3801 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3804 self.field_ty(field.span, v_field, substs)
3806 error_happened = true;
3807 if let Some(prev_span) = seen_fields.get(&ident) {
3808 let mut err = struct_span_err!(self.tcx.sess,
3811 "field `{}` specified more than once",
3814 err.span_label(field.ident.span, "used more than once");
3815 err.span_label(*prev_span, format!("first use of `{}`", ident));
3819 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3825 // Make sure to give a type to the field even if there's
3826 // an error, so we can continue type-checking.
3827 self.check_expr_coercable_to_type(&field.expr, field_type);
3830 // Make sure the programmer specified correct number of fields.
3831 if kind_name == "union" {
3832 if ast_fields.len() != 1 {
3833 tcx.sess.span_err(span, "union expressions should have exactly one field");
3835 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3836 let len = remaining_fields.len();
3838 let mut displayable_field_names = remaining_fields
3840 .map(|ident| ident.as_str())
3841 .collect::<Vec<_>>();
3843 displayable_field_names.sort();
3845 let truncated_fields_error = if len <= 3 {
3848 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3851 let remaining_fields_names = displayable_field_names.iter().take(3)
3852 .map(|n| format!("`{}`", n))
3853 .collect::<Vec<_>>()
3856 struct_span_err!(tcx.sess, span, E0063,
3857 "missing field{} {}{} in initializer of `{}`",
3858 if remaining_fields.len() == 1 { "" } else { "s" },
3859 remaining_fields_names,
3860 truncated_fields_error,
3862 .span_label(span, format!("missing {}{}",
3863 remaining_fields_names,
3864 truncated_fields_error))
3870 fn check_struct_fields_on_error(&self,
3871 fields: &'gcx [hir::Field],
3872 base_expr: &'gcx Option<P<hir::Expr>>) {
3873 for field in fields {
3874 self.check_expr(&field.expr);
3876 if let Some(ref base) = *base_expr {
3877 self.check_expr(&base);
3881 pub fn check_struct_path(&self,
3884 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3885 let path_span = match *qpath {
3886 QPath::Resolved(_, ref path) => path.span,
3887 QPath::TypeRelative(ref qself, _) => qself.span
3889 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3890 let variant = match def {
3892 self.set_tainted_by_errors();
3895 Def::Variant(..) => {
3897 ty::Adt(adt, substs) => {
3898 Some((adt.variant_of_def(def), adt.did, substs))
3900 _ => bug!("unexpected type: {:?}", ty.sty)
3903 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3904 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3906 ty::Adt(adt, substs) if !adt.is_enum() => {
3907 Some((adt.non_enum_variant(), adt.did, substs))
3912 _ => bug!("unexpected definition: {:?}", def)
3915 if let Some((variant, did, substs)) = variant {
3916 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3917 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3919 // Check bounds on type arguments used in the path.
3920 let bounds = self.instantiate_bounds(path_span, did, substs);
3921 let cause = traits::ObligationCause::new(path_span, self.body_id,
3922 traits::ItemObligation(did));
3923 self.add_obligations_for_parameters(cause, &bounds);
3927 struct_span_err!(self.tcx.sess, path_span, E0071,
3928 "expected struct, variant or union type, found {}",
3929 ty.sort_string(self.tcx))
3930 .span_label(path_span, "not a struct")
3936 fn check_expr_struct(&self,
3938 expected: Expectation<'tcx>,
3940 fields: &'gcx [hir::Field],
3941 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3943 // Find the relevant variant
3944 let (variant, adt_ty) =
3945 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3948 self.check_struct_fields_on_error(fields, base_expr);
3949 return self.tcx.types.err;
3952 let path_span = match *qpath {
3953 QPath::Resolved(_, ref path) => path.span,
3954 QPath::TypeRelative(ref qself, _) => qself.span
3957 // Prohibit struct expressions when non-exhaustive flag is set.
3958 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3959 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3960 span_err!(self.tcx.sess, expr.span, E0639,
3961 "cannot create non-exhaustive {} using struct expression",
3962 adt.variant_descr());
3965 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3966 variant, fields, base_expr.is_none());
3967 if let &Some(ref base_expr) = base_expr {
3968 // If check_expr_struct_fields hit an error, do not attempt to populate
3969 // the fields with the base_expr. This could cause us to hit errors later
3970 // when certain fields are assumed to exist that in fact do not.
3971 if !error_happened {
3972 self.check_expr_has_type_or_error(base_expr, adt_ty);
3974 ty::Adt(adt, substs) if adt.is_struct() => {
3975 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3976 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3981 .fru_field_types_mut()
3982 .insert(expr.hir_id, fru_field_types);
3985 span_err!(self.tcx.sess, base_expr.span, E0436,
3986 "functional record update syntax requires a struct");
3991 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3997 /// If an expression has any sub-expressions that result in a type error,
3998 /// inspecting that expression's type with `ty.references_error()` will return
3999 /// true. Likewise, if an expression is known to diverge, inspecting its
4000 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
4001 /// strict, _|_ can appear in the type of an expression that does not,
4002 /// itself, diverge: for example, fn() -> _|_.)
4003 /// Note that inspecting a type's structure *directly* may expose the fact
4004 /// that there are actually multiple representations for `Error`, so avoid
4005 /// that when err needs to be handled differently.
4006 fn check_expr_with_expectation_and_needs(&self,
4007 expr: &'gcx hir::Expr,
4008 expected: Expectation<'tcx>,
4009 needs: Needs) -> Ty<'tcx> {
4010 debug!(">> type-checking: expr={:?} expected={:?}",
4013 // Warn for expressions after diverging siblings.
4014 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
4016 // Hide the outer diverging and has_errors flags.
4017 let old_diverges = self.diverges.get();
4018 let old_has_errors = self.has_errors.get();
4019 self.diverges.set(Diverges::Maybe);
4020 self.has_errors.set(false);
4022 let ty = self.check_expr_kind(expr, expected, needs);
4024 // Warn for non-block expressions with diverging children.
4026 ExprKind::Block(..) |
4027 ExprKind::Loop(..) | ExprKind::While(..) |
4028 ExprKind::If(..) | ExprKind::Match(..) => {}
4030 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
4033 // Any expression that produces a value of type `!` must have diverged
4035 self.diverges.set(self.diverges.get() | Diverges::Always);
4038 // Record the type, which applies it effects.
4039 // We need to do this after the warning above, so that
4040 // we don't warn for the diverging expression itself.
4041 self.write_ty(expr.hir_id, ty);
4043 // Combine the diverging and has_error flags.
4044 self.diverges.set(self.diverges.get() | old_diverges);
4045 self.has_errors.set(self.has_errors.get() | old_has_errors);
4047 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
4048 debug!("... {:?}, expected is {:?}", ty, expected);
4055 expr: &'gcx hir::Expr,
4056 expected: Expectation<'tcx>,
4060 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
4067 let id = expr.hir_id;
4069 ExprKind::Box(ref subexpr) => {
4070 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
4072 ty::Adt(def, _) if def.is_box()
4073 => Expectation::rvalue_hint(self, ty.boxed_ty()),
4077 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
4078 tcx.mk_box(referent_ty)
4081 ExprKind::Lit(ref lit) => {
4082 self.check_lit(&lit, expected)
4084 ExprKind::Binary(op, ref lhs, ref rhs) => {
4085 self.check_binop(expr, op, lhs, rhs)
4087 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
4088 self.check_binop_assign(expr, op, lhs, rhs)
4090 ExprKind::Unary(unop, ref oprnd) => {
4091 let expected_inner = match unop {
4092 hir::UnNot | hir::UnNeg => {
4099 let needs = match unop {
4100 hir::UnDeref => needs,
4103 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
4107 if !oprnd_t.references_error() {
4108 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
4111 if let Some(mt) = oprnd_t.builtin_deref(true) {
4113 } else if let Some(ok) = self.try_overloaded_deref(
4114 expr.span, oprnd_t, needs) {
4115 let method = self.register_infer_ok_obligations(ok);
4116 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
4117 let mutbl = match mutbl {
4118 hir::MutImmutable => AutoBorrowMutability::Immutable,
4119 hir::MutMutable => AutoBorrowMutability::Mutable {
4120 // (It shouldn't actually matter for unary ops whether
4121 // we enable two-phase borrows or not, since a unary
4122 // op has no additional operands.)
4123 allow_two_phase_borrow: AllowTwoPhase::No,
4126 self.apply_adjustments(oprnd, vec![Adjustment {
4127 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4128 target: method.sig.inputs()[0]
4131 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4132 self.write_method_call(expr.hir_id, method);
4134 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
4135 "type `{}` cannot be dereferenced",
4137 oprnd_t = tcx.types.err;
4141 let result = self.check_user_unop(expr, oprnd_t, unop);
4142 // If it's builtin, we can reuse the type, this helps inference.
4143 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4148 let result = self.check_user_unop(expr, oprnd_t, unop);
4149 // If it's builtin, we can reuse the type, this helps inference.
4150 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4158 ExprKind::AddrOf(mutbl, ref oprnd) => {
4159 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4161 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4162 if oprnd.is_place_expr() {
4163 // Places may legitimately have unsized types.
4164 // For example, dereferences of a fat pointer and
4165 // the last field of a struct can be unsized.
4168 Expectation::rvalue_hint(self, ty)
4174 let needs = Needs::maybe_mut_place(mutbl);
4175 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4177 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4178 if tm.ty.references_error() {
4181 // Note: at this point, we cannot say what the best lifetime
4182 // is to use for resulting pointer. We want to use the
4183 // shortest lifetime possible so as to avoid spurious borrowck
4184 // errors. Moreover, the longest lifetime will depend on the
4185 // precise details of the value whose address is being taken
4186 // (and how long it is valid), which we don't know yet until type
4187 // inference is complete.
4189 // Therefore, here we simply generate a region variable. The
4190 // region inferencer will then select the ultimate value.
4191 // Finally, borrowck is charged with guaranteeing that the
4192 // value whose address was taken can actually be made to live
4193 // as long as it needs to live.
4194 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4195 tcx.mk_ref(region, tm)
4198 ExprKind::Path(ref qpath) => {
4199 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.hir_id,
4201 let ty = match def {
4203 self.set_tainted_by_errors();
4206 Def::VariantCtor(_, CtorKind::Fictive) => {
4207 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4210 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4213 if let ty::FnDef(..) = ty.sty {
4214 let fn_sig = ty.fn_sig(tcx);
4215 if !tcx.features().unsized_locals {
4216 // We want to remove some Sized bounds from std functions,
4217 // but don't want to expose the removal to stable Rust.
4218 // i.e., we don't want to allow
4224 // to work in stable even if the Sized bound on `drop` is relaxed.
4225 for i in 0..fn_sig.inputs().skip_binder().len() {
4226 // We just want to check sizedness, so instead of introducing
4227 // placeholder lifetimes with probing, we just replace higher lifetimes
4229 let input = self.replace_bound_vars_with_fresh_vars(
4231 infer::LateBoundRegionConversionTime::FnCall,
4232 &fn_sig.input(i)).0;
4233 self.require_type_is_sized_deferred(input, expr.span,
4234 traits::SizedArgumentType);
4237 // Here we want to prevent struct constructors from returning unsized types.
4238 // There were two cases this happened: fn pointer coercion in stable
4239 // and usual function call in presense of unsized_locals.
4240 // Also, as we just want to check sizedness, instead of introducing
4241 // placeholder lifetimes with probing, we just replace higher lifetimes
4243 let output = self.replace_bound_vars_with_fresh_vars(
4245 infer::LateBoundRegionConversionTime::FnCall,
4246 &fn_sig.output()).0;
4247 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4250 // We always require that the type provided as the value for
4251 // a type parameter outlives the moment of instantiation.
4252 let substs = self.tables.borrow().node_substs(expr.hir_id);
4253 self.add_wf_bounds(substs, expr);
4257 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4258 for expr in outputs.iter().chain(inputs.iter()) {
4259 self.check_expr(expr);
4263 ExprKind::Break(destination, ref expr_opt) => {
4264 if let Ok(target_id) = destination.target_id {
4265 let target_id = tcx.hir().node_to_hir_id(target_id);
4267 if let Some(ref e) = *expr_opt {
4268 // If this is a break with a value, we need to type-check
4269 // the expression. Get an expected type from the loop context.
4270 let opt_coerce_to = {
4271 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4272 enclosing_breakables.find_breakable(target_id)
4275 .map(|coerce| coerce.expected_ty())
4278 // If the loop context is not a `loop { }`, then break with
4279 // a value is illegal, and `opt_coerce_to` will be `None`.
4280 // Just set expectation to error in that case.
4281 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4283 // Recurse without `enclosing_breakables` borrowed.
4284 e_ty = self.check_expr_with_hint(e, coerce_to);
4285 cause = self.misc(e.span);
4287 // Otherwise, this is a break *without* a value. That's
4288 // always legal, and is equivalent to `break ()`.
4289 e_ty = tcx.mk_unit();
4290 cause = self.misc(expr.span);
4293 // Now that we have type-checked `expr_opt`, borrow
4294 // the `enclosing_loops` field and let's coerce the
4295 // type of `expr_opt` into what is expected.
4296 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4297 let ctxt = enclosing_breakables.find_breakable(target_id);
4298 if let Some(ref mut coerce) = ctxt.coerce {
4299 if let Some(ref e) = *expr_opt {
4300 coerce.coerce(self, &cause, e, e_ty);
4302 assert!(e_ty.is_unit());
4303 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4306 // If `ctxt.coerce` is `None`, we can just ignore
4307 // the type of the expresison. This is because
4308 // either this was a break *without* a value, in
4309 // which case it is always a legal type (`()`), or
4310 // else an error would have been flagged by the
4311 // `loops` pass for using break with an expression
4312 // where you are not supposed to.
4313 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4316 ctxt.may_break = true;
4318 // the type of a `break` is always `!`, since it diverges
4321 // Otherwise, we failed to find the enclosing loop;
4322 // this can only happen if the `break` was not
4323 // inside a loop at all, which is caught by the
4324 // loop-checking pass.
4325 if self.tcx.sess.err_count() == 0 {
4326 self.tcx.sess.delay_span_bug(expr.span,
4327 "break was outside loop, but no error was emitted");
4330 // We still need to assign a type to the inner expression to
4331 // prevent the ICE in #43162.
4332 if let Some(ref e) = *expr_opt {
4333 self.check_expr_with_hint(e, tcx.types.err);
4335 // ... except when we try to 'break rust;'.
4336 // ICE this expression in particular (see #43162).
4337 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4338 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4339 fatally_break_rust(self.tcx.sess);
4343 // There was an error; make type-check fail.
4348 ExprKind::Continue(destination) => {
4349 if destination.target_id.is_ok() {
4352 // There was an error; make type-check fail.
4356 ExprKind::Ret(ref expr_opt) => {
4357 if self.ret_coercion.is_none() {
4358 struct_span_err!(self.tcx.sess, expr.span, E0572,
4359 "return statement outside of function body").emit();
4360 } else if let Some(ref e) = *expr_opt {
4361 if self.ret_coercion_span.borrow().is_none() {
4362 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4364 self.check_return_expr(e);
4366 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4367 if self.ret_coercion_span.borrow().is_none() {
4368 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4370 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4371 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4372 coercion.coerce_forced_unit(
4377 fn_decl.output.span(),
4379 "expected `{}` because of this return type",
4387 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4392 ExprKind::Assign(ref lhs, ref rhs) => {
4393 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4395 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4398 ExpectIfCondition => {
4399 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4400 expected error elsehwere");
4403 // Only check this if not in an `if` condition, as the
4404 // mistyped comparison help is more appropriate.
4405 if !lhs.is_place_expr() {
4406 struct_span_err!(self.tcx.sess, expr.span, E0070,
4407 "invalid left-hand side expression")
4408 .span_label(expr.span, "left-hand of expression not valid")
4414 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4416 if lhs_ty.references_error() || rhs_ty.references_error() {
4422 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4423 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4424 expr.span, expected)
4426 ExprKind::While(ref cond, ref body, _) => {
4427 let ctxt = BreakableCtxt {
4428 // cannot use break with a value from a while loop
4430 may_break: false, // Will get updated if/when we find a `break`.
4433 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4434 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4435 let cond_diverging = self.diverges.get();
4436 self.check_block_no_value(&body);
4438 // We may never reach the body so it diverging means nothing.
4439 self.diverges.set(cond_diverging);
4443 // No way to know whether it's diverging because
4444 // of a `break` or an outer `break` or `return`.
4445 self.diverges.set(Diverges::Maybe);
4450 ExprKind::Loop(ref body, _, source) => {
4451 let coerce = match source {
4452 // you can only use break with a value from a normal `loop { }`
4453 hir::LoopSource::Loop => {
4454 let coerce_to = expected.coercion_target_type(self, body.span);
4455 Some(CoerceMany::new(coerce_to))
4458 hir::LoopSource::WhileLet |
4459 hir::LoopSource::ForLoop => {
4464 let ctxt = BreakableCtxt {
4466 may_break: false, // Will get updated if/when we find a `break`.
4469 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4470 self.check_block_no_value(&body);
4474 // No way to know whether it's diverging because
4475 // of a `break` or an outer `break` or `return`.
4476 self.diverges.set(Diverges::Maybe);
4479 // If we permit break with a value, then result type is
4480 // the LUB of the breaks (possibly ! if none); else, it
4481 // is nil. This makes sense because infinite loops
4482 // (which would have type !) are only possible iff we
4483 // permit break with a value [1].
4484 if ctxt.coerce.is_none() && !ctxt.may_break {
4486 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4488 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4490 ExprKind::Match(ref discrim, ref arms, match_src) => {
4491 self.check_match(expr, &discrim, arms, expected, match_src)
4493 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4494 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4496 ExprKind::Block(ref body, _) => {
4497 self.check_block_with_expected(&body, expected)
4499 ExprKind::Call(ref callee, ref args) => {
4500 self.check_call(expr, &callee, args, expected)
4502 ExprKind::MethodCall(ref segment, span, ref args) => {
4503 self.check_method_call(expr, segment, span, args, expected, needs)
4505 ExprKind::Cast(ref e, ref t) => {
4506 // Find the type of `e`. Supply hints based on the type we are casting to,
4508 let t_cast = self.to_ty_saving_user_provided_ty(t);
4509 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4510 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4511 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4513 // Eagerly check for some obvious errors.
4514 if t_expr.references_error() || t_cast.references_error() {
4517 // Defer other checks until we're done type checking.
4518 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4519 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4521 deferred_cast_checks.push(cast_check);
4524 Err(ErrorReported) => {
4530 ExprKind::Type(ref e, ref t) => {
4531 let ty = self.to_ty_saving_user_provided_ty(&t);
4532 self.check_expr_eq_type(&e, ty);
4535 ExprKind::Array(ref args) => {
4536 let uty = expected.to_option(self).and_then(|uty| {
4538 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4543 let element_ty = if !args.is_empty() {
4544 let coerce_to = uty.unwrap_or_else(
4545 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4546 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4547 assert_eq!(self.diverges.get(), Diverges::Maybe);
4549 let e_ty = self.check_expr_with_hint(e, coerce_to);
4550 let cause = self.misc(e.span);
4551 coerce.coerce(self, &cause, e, e_ty);
4553 coerce.complete(self)
4555 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4557 tcx.mk_array(element_ty, args.len() as u64)
4559 ExprKind::Repeat(ref element, ref count) => {
4560 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4561 let param_env = ty::ParamEnv::empty();
4562 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4563 let instance = ty::Instance::resolve(
4569 let global_id = GlobalId {
4573 let count = tcx.const_eval(param_env.and(global_id));
4575 let uty = match expected {
4576 ExpectHasType(uty) => {
4578 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4585 let (element_ty, t) = match uty {
4587 self.check_expr_coercable_to_type(&element, uty);
4591 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4592 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4597 if let Ok(count) = count {
4598 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4600 // For [foo, ..n] where n > 1, `foo` must have
4602 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4603 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4607 if element_ty.references_error() {
4609 } else if let Ok(count) = count {
4610 tcx.mk_ty(ty::Array(t, tcx.mk_lazy_const(ty::LazyConst::Evaluated(count))))
4615 ExprKind::Tup(ref elts) => {
4616 let flds = expected.only_has_type(self).and_then(|ty| {
4617 let ty = self.resolve_type_vars_with_obligations(ty);
4619 ty::Tuple(ref flds) => Some(&flds[..]),
4624 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4625 let t = match flds {
4626 Some(ref fs) if i < fs.len() => {
4628 self.check_expr_coercable_to_type(&e, ety);
4632 self.check_expr_with_expectation(&e, NoExpectation)
4637 let tuple = tcx.mk_tup(elt_ts_iter);
4638 if tuple.references_error() {
4641 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4645 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4646 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4648 ExprKind::Field(ref base, field) => {
4649 self.check_field(expr, needs, &base, field)
4651 ExprKind::Index(ref base, ref idx) => {
4652 let base_t = self.check_expr_with_needs(&base, needs);
4653 let idx_t = self.check_expr(&idx);
4655 if base_t.references_error() {
4657 } else if idx_t.references_error() {
4660 let base_t = self.structurally_resolved_type(base.span, base_t);
4661 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4662 Some((index_ty, element_ty)) => {
4663 // two-phase not needed because index_ty is never mutable
4664 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4669 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4670 "cannot index into a value of type `{}`",
4672 // Try to give some advice about indexing tuples.
4673 if let ty::Tuple(..) = base_t.sty {
4674 let mut needs_note = true;
4675 // If the index is an integer, we can show the actual
4676 // fixed expression:
4677 if let ExprKind::Lit(ref lit) = idx.node {
4678 if let ast::LitKind::Int(i,
4679 ast::LitIntType::Unsuffixed) = lit.node {
4680 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4681 if let Ok(snip) = snip {
4682 err.span_suggestion(
4684 "to access tuple elements, use",
4685 format!("{}.{}", snip, i),
4686 Applicability::MachineApplicable,
4693 err.help("to access tuple elements, use tuple indexing \
4694 syntax (e.g., `tuple.0`)");
4703 ExprKind::Yield(ref value) => {
4704 match self.yield_ty {
4706 self.check_expr_coercable_to_type(&value, ty);
4709 struct_span_err!(self.tcx.sess, expr.span, E0627,
4710 "yield statement outside of generator literal").emit();
4715 hir::ExprKind::Err => {
4721 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4722 // The newly resolved definition is written into `type_dependent_defs`.
4723 fn finish_resolving_struct_path(&self,
4730 QPath::Resolved(ref maybe_qself, ref path) => {
4731 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4732 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4735 QPath::TypeRelative(ref qself, ref segment) => {
4736 let ty = self.to_ty(qself);
4738 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4743 let (ty, def) = AstConv::associated_path_to_ty(self, hir_id, path_span,
4744 ty, def, segment, true);
4746 // Write back the new resolution.
4747 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4754 /// Resolves associated value path into a base type and associated constant or method
4755 /// definition. The newly resolved definition is written into `type_dependent_defs`.
4756 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4760 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4762 debug!("resolve_ty_and_def_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4763 let (ty, qself, item_segment) = match *qpath {
4764 QPath::Resolved(ref opt_qself, ref path) => {
4766 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4767 &path.segments[..]);
4769 QPath::TypeRelative(ref qself, ref segment) => {
4770 (self.to_ty(qself), qself, segment)
4773 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4774 // Return directly on cache hit. This is useful to avoid doubly reporting
4775 // errors with default match binding modes. See #44614.
4776 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4778 let item_name = item_segment.ident;
4779 let def = match self.resolve_ufcs(span, item_name, ty, hir_id) {
4782 let def = match error {
4783 method::MethodError::PrivateMatch(def, _) => def,
4786 if item_name.name != keywords::Invalid.name() {
4787 self.report_method_error(span,
4790 SelfSource::QPath(qself),
4798 // Write back the new resolution.
4799 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4800 (def, Some(ty), slice::from_ref(&**item_segment))
4803 pub fn check_decl_initializer(&self,
4804 local: &'gcx hir::Local,
4805 init: &'gcx hir::Expr) -> Ty<'tcx>
4807 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4808 // for #42640 (default match binding modes).
4811 let ref_bindings = local.pat.contains_explicit_ref_binding();
4813 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4814 if let Some(m) = ref_bindings {
4815 // Somewhat subtle: if we have a `ref` binding in the pattern,
4816 // we want to avoid introducing coercions for the RHS. This is
4817 // both because it helps preserve sanity and, in the case of
4818 // ref mut, for soundness (issue #23116). In particular, in
4819 // the latter case, we need to be clear that the type of the
4820 // referent for the reference that results is *equal to* the
4821 // type of the place it is referencing, and not some
4822 // supertype thereof.
4823 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4824 self.demand_eqtype(init.span, local_ty, init_ty);
4827 self.check_expr_coercable_to_type(init, local_ty)
4831 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4832 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4833 self.write_ty(local.hir_id, t);
4835 if let Some(ref init) = local.init {
4836 let init_ty = self.check_decl_initializer(local, &init);
4837 if init_ty.references_error() {
4838 self.write_ty(local.hir_id, init_ty);
4842 self.check_pat_walk(
4845 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4848 let pat_ty = self.node_ty(local.pat.hir_id);
4849 if pat_ty.references_error() {
4850 self.write_ty(local.hir_id, pat_ty);
4854 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4855 // Don't do all the complex logic below for `DeclItem`.
4857 hir::StmtKind::Item(..) => return,
4858 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4861 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4863 // Hide the outer diverging and `has_errors` flags.
4864 let old_diverges = self.diverges.get();
4865 let old_has_errors = self.has_errors.get();
4866 self.diverges.set(Diverges::Maybe);
4867 self.has_errors.set(false);
4870 hir::StmtKind::Local(ref l) => {
4871 self.check_decl_local(&l);
4874 hir::StmtKind::Item(_) => {}
4875 hir::StmtKind::Expr(ref expr) => {
4876 // Check with expected type of `()`.
4877 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4879 hir::StmtKind::Semi(ref expr) => {
4880 self.check_expr(&expr);
4884 // Combine the diverging and `has_error` flags.
4885 self.diverges.set(self.diverges.get() | old_diverges);
4886 self.has_errors.set(self.has_errors.get() | old_has_errors);
4889 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4890 let unit = self.tcx.mk_unit();
4891 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4893 // if the block produces a `!` value, that can always be
4894 // (effectively) coerced to unit.
4896 self.demand_suptype(blk.span, unit, ty);
4900 fn check_block_with_expected(&self,
4901 blk: &'gcx hir::Block,
4902 expected: Expectation<'tcx>) -> Ty<'tcx> {
4904 let mut fcx_ps = self.ps.borrow_mut();
4905 let unsafety_state = fcx_ps.recurse(blk);
4906 replace(&mut *fcx_ps, unsafety_state)
4909 // In some cases, blocks have just one exit, but other blocks
4910 // can be targeted by multiple breaks. This can happen both
4911 // with labeled blocks as well as when we desugar
4912 // a `try { ... }` expression.
4916 // 'a: { if true { break 'a Err(()); } Ok(()) }
4918 // Here we would wind up with two coercions, one from
4919 // `Err(())` and the other from the tail expression
4920 // `Ok(())`. If the tail expression is omitted, that's a
4921 // "forced unit" -- unless the block diverges, in which
4922 // case we can ignore the tail expression (e.g., `'a: {
4923 // break 'a 22; }` would not force the type of the block
4925 let tail_expr = blk.expr.as_ref();
4926 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4927 let coerce = if blk.targeted_by_break {
4928 CoerceMany::new(coerce_to_ty)
4930 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4931 Some(e) => slice::from_ref(e),
4934 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4937 let prev_diverges = self.diverges.get();
4938 let ctxt = BreakableCtxt {
4939 coerce: Some(coerce),
4943 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4944 for s in &blk.stmts {
4948 // check the tail expression **without** holding the
4949 // `enclosing_breakables` lock below.
4950 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4952 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4953 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4954 let coerce = ctxt.coerce.as_mut().unwrap();
4955 if let Some(tail_expr_ty) = tail_expr_ty {
4956 let tail_expr = tail_expr.unwrap();
4957 let cause = self.cause(tail_expr.span,
4958 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4964 // Subtle: if there is no explicit tail expression,
4965 // that is typically equivalent to a tail expression
4966 // of `()` -- except if the block diverges. In that
4967 // case, there is no value supplied from the tail
4968 // expression (assuming there are no other breaks,
4969 // this implies that the type of the block will be
4972 // #41425 -- label the implicit `()` as being the
4973 // "found type" here, rather than the "expected type".
4974 if !self.diverges.get().always() {
4975 // #50009 -- Do not point at the entire fn block span, point at the return type
4976 // span, as it is the cause of the requirement, and
4977 // `consider_hint_about_removing_semicolon` will point at the last expression
4978 // if it were a relevant part of the error. This improves usability in editors
4979 // that highlight errors inline.
4980 let mut sp = blk.span;
4981 let mut fn_span = None;
4982 let blk_node_id = self.tcx.hir().hir_to_node_id(blk.hir_id);
4983 if let Some((decl, ident)) = self.get_parent_fn_decl(blk_node_id) {
4984 let ret_sp = decl.output.span();
4985 if let Some(block_sp) = self.parent_item_span(blk_node_id) {
4986 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4987 // output would otherwise be incorrect and even misleading. Make sure
4988 // the span we're aiming at correspond to a `fn` body.
4989 if block_sp == blk.span {
4991 fn_span = Some(ident.span);
4995 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4996 if let Some(expected_ty) = expected.only_has_type(self) {
4997 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4999 if let Some(fn_span) = fn_span {
5000 err.span_label(fn_span, "this function's body doesn't return");
5008 // If we can break from the block, then the block's exit is always reachable
5009 // (... as long as the entry is reachable) - regardless of the tail of the block.
5010 self.diverges.set(prev_diverges);
5013 let mut ty = ctxt.coerce.unwrap().complete(self);
5015 if self.has_errors.get() || ty.references_error() {
5016 ty = self.tcx.types.err
5019 self.write_ty(blk.hir_id, ty);
5021 *self.ps.borrow_mut() = prev;
5025 fn parent_item_span(&self, id: ast::NodeId) -> Option<Span> {
5026 let node = self.tcx.hir().get(self.tcx.hir().get_parent(id));
5028 Node::Item(&hir::Item {
5029 node: hir::ItemKind::Fn(_, _, _, body_id), ..
5031 Node::ImplItem(&hir::ImplItem {
5032 node: hir::ImplItemKind::Method(_, body_id), ..
5034 let body = self.tcx.hir().body(body_id);
5035 if let ExprKind::Block(block, _) = &body.value.node {
5036 return Some(block.span);
5044 /// Given a function block's `NodeId`, returns its `FnDecl` if it exists, or `None` otherwise.
5045 fn get_parent_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, ast::Ident)> {
5046 let parent = self.tcx.hir().get(self.tcx.hir().get_parent(blk_id));
5047 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
5050 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
5051 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
5053 Node::Item(&hir::Item {
5054 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
5055 }) => decl.clone().and_then(|decl| {
5056 // This is less than ideal, it will not suggest a return type span on any
5057 // method called `main`, regardless of whether it is actually the entry point,
5058 // but it will still present it as the reason for the expected type.
5059 Some((decl, ident, ident.name != Symbol::intern("main")))
5061 Node::TraitItem(&hir::TraitItem {
5062 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5065 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5066 Node::ImplItem(&hir::ImplItem {
5067 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5070 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5075 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
5076 /// suggestion can be made, `None` otherwise.
5077 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
5078 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5079 // `while` before reaching it, as block tail returns are not available in them.
5080 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5081 let parent = self.tcx.hir().get_by_hir_id(blk_id);
5082 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5086 /// On implicit return expressions with mismatched types, provides the following suggestions:
5088 /// - Points out the method's return type as the reason for the expected type.
5089 /// - Possible missing semicolon.
5090 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5091 pub fn suggest_mismatched_types_on_tail(
5093 err: &mut DiagnosticBuilder<'tcx>,
5094 expression: &'gcx hir::Expr,
5100 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5101 let mut pointing_at_return_type = false;
5102 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5103 pointing_at_return_type = self.suggest_missing_return_type(
5104 err, &fn_decl, expected, found, can_suggest);
5106 self.suggest_ref_or_into(err, expression, expected, found);
5107 pointing_at_return_type
5110 pub fn suggest_ref_or_into(
5112 err: &mut DiagnosticBuilder<'tcx>,
5117 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5118 err.span_suggestion(
5122 Applicability::MachineApplicable,
5124 } else if !self.check_for_cast(err, expr, found, expected) {
5125 let methods = self.get_conversion_methods(expr.span, expected, found);
5126 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5127 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5128 .filter_map(|(receiver, method)| {
5129 let method_call = format!(".{}()", method.ident);
5130 if receiver.ends_with(&method_call) {
5131 None // do not suggest code that is already there (#53348)
5133 let method_call_list = [".to_vec()", ".to_string()"];
5134 if receiver.ends_with(".clone()")
5135 && method_call_list.contains(&method_call.as_str()) {
5136 let max_len = receiver.rfind(".").unwrap();
5137 Some(format!("{}{}", &receiver[..max_len], method_call))
5140 Some(format!("{}{}", receiver, method_call))
5144 if suggestions.peek().is_some() {
5145 err.span_suggestions(
5147 "try using a conversion method",
5149 Applicability::MaybeIncorrect,
5156 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5160 /// bar_that_returns_u32()
5164 /// This routine checks if the return expression in a block would make sense on its own as a
5165 /// statement and the return type has been left as default or has been specified as `()`. If so,
5166 /// it suggests adding a semicolon.
5167 fn suggest_missing_semicolon(&self,
5168 err: &mut DiagnosticBuilder<'tcx>,
5169 expression: &'gcx hir::Expr,
5172 if expected.is_unit() {
5173 // `BlockTailExpression` only relevant if the tail expr would be
5174 // useful on its own.
5175 match expression.node {
5176 ExprKind::Call(..) |
5177 ExprKind::MethodCall(..) |
5179 ExprKind::While(..) |
5180 ExprKind::Loop(..) |
5181 ExprKind::Match(..) |
5182 ExprKind::Block(..) => {
5183 let sp = self.tcx.sess.source_map().next_point(cause_span);
5184 err.span_suggestion(
5186 "try adding a semicolon",
5188 Applicability::MachineApplicable);
5195 /// A possible error is to forget to add a return type that is needed:
5199 /// bar_that_returns_u32()
5203 /// This routine checks if the return type is left as default, the method is not part of an
5204 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5206 fn suggest_missing_return_type(
5208 err: &mut DiagnosticBuilder<'tcx>,
5209 fn_decl: &hir::FnDecl,
5214 // Only suggest changing the return type for methods that
5215 // haven't set a return type at all (and aren't `fn main()` or an impl).
5216 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5217 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5218 err.span_suggestion(
5220 "try adding a return type",
5221 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5222 Applicability::MachineApplicable);
5225 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5226 err.span_label(span, "possibly return type missing here?");
5229 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5230 // `fn main()` must return `()`, do not suggest changing return type
5231 err.span_label(span, "expected `()` because of default return type");
5234 // expectation was caused by something else, not the default return
5235 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5236 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5237 // Only point to return type if the expected type is the return type, as if they
5238 // are not, the expectation must have been caused by something else.
5239 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5241 let ty = AstConv::ast_ty_to_ty(self, ty);
5242 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5243 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5244 if ty.sty == expected.sty {
5245 err.span_label(sp, format!("expected `{}` because of return type",
5254 /// A common error is to add an extra semicolon:
5257 /// fn foo() -> usize {
5262 /// This routine checks if the final statement in a block is an
5263 /// expression with an explicit semicolon whose type is compatible
5264 /// with `expected_ty`. If so, it suggests removing the semicolon.
5265 fn consider_hint_about_removing_semicolon(
5267 blk: &'gcx hir::Block,
5268 expected_ty: Ty<'tcx>,
5269 err: &mut DiagnosticBuilder<'_>,
5271 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5272 err.span_suggestion(
5274 "consider removing this semicolon",
5276 Applicability::MachineApplicable,
5281 fn could_remove_semicolon(
5283 blk: &'gcx hir::Block,
5284 expected_ty: Ty<'tcx>,
5286 // Be helpful when the user wrote `{... expr;}` and
5287 // taking the `;` off is enough to fix the error.
5288 let last_stmt = match blk.stmts.last() {
5290 None => return None,
5292 let last_expr = match last_stmt.node {
5293 hir::StmtKind::Semi(ref e) => e,
5296 let last_expr_ty = self.node_ty(last_expr.hir_id);
5297 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5300 let original_span = original_sp(last_stmt.span, blk.span);
5301 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5304 // Instantiates the given path, which must refer to an item with the given
5305 // number of type parameters and type.
5306 pub fn instantiate_value_path(&self,
5307 segments: &[hir::PathSegment],
5308 self_ty: Option<Ty<'tcx>>,
5312 -> (Ty<'tcx>, Def) {
5314 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, hir_id={})",
5323 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5325 let mut user_self_ty = None;
5326 let mut is_alias_variant_ctor = false;
5328 Def::VariantCtor(_, _) => {
5329 if let Some(self_ty) = self_ty {
5330 let adt_def = self_ty.ty_adt_def().unwrap();
5331 user_self_ty = Some(UserSelfTy {
5332 impl_def_id: adt_def.did,
5335 is_alias_variant_ctor = true;
5338 Def::Method(def_id) |
5339 Def::AssociatedConst(def_id) => {
5340 let container = tcx.associated_item(def_id).container;
5341 debug!("instantiate_value_path: def={:?} container={:?}", def, container);
5343 ty::TraitContainer(trait_did) => {
5344 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5346 ty::ImplContainer(impl_def_id) => {
5347 if segments.len() == 1 {
5348 // `<T>::assoc` will end up here, and so
5349 // can `T::assoc`. It this came from an
5350 // inherent impl, we need to record the
5351 // `T` for posterity (see `UserSelfTy` for
5353 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5354 user_self_ty = Some(UserSelfTy {
5365 // Now that we have categorized what space the parameters for each
5366 // segment belong to, let's sort out the parameters that the user
5367 // provided (if any) into their appropriate spaces. We'll also report
5368 // errors if type parameters are provided in an inappropriate place.
5370 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5371 let generics_has_err = AstConv::prohibit_generics(
5372 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5373 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5379 if generics_has_err {
5380 // Don't try to infer type parameters when prohibited generic arguments were given.
5381 user_self_ty = None;
5385 Def::Local(nid) | Def::Upvar(nid, ..) => {
5386 let hid = self.tcx.hir().node_to_hir_id(nid);
5387 let ty = self.local_ty(span, hid).decl_ty;
5388 let ty = self.normalize_associated_types_in(span, &ty);
5389 self.write_ty(hir_id, ty);
5395 // Now we have to compare the types that the user *actually*
5396 // provided against the types that were *expected*. If the user
5397 // did not provide any types, then we want to substitute inference
5398 // variables. If the user provided some types, we may still need
5399 // to add defaults. If the user provided *too many* types, that's
5402 let mut infer_args_for_err = FxHashSet::default();
5403 for &PathSeg(def_id, index) in &path_segs {
5404 let seg = &segments[index];
5405 let generics = tcx.generics_of(def_id);
5406 // Argument-position `impl Trait` is treated as a normal generic
5407 // parameter internally, but we don't allow users to specify the
5408 // parameter's value explicitly, so we have to do some error-
5410 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5415 false, // `is_method_call`
5417 if suppress_errors {
5418 infer_args_for_err.insert(index);
5419 self.set_tainted_by_errors(); // See issue #53251.
5423 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5424 tcx.generics_of(*def_id).has_self
5425 }).unwrap_or(false);
5427 let mut new_def = def;
5428 let (def_id, ty) = match def {
5429 Def::SelfCtor(impl_def_id) => {
5430 let ty = self.impl_self_ty(span, impl_def_id).ty;
5431 let adt_def = ty.ty_adt_def();
5434 Some(adt_def) if adt_def.has_ctor() => {
5435 let variant = adt_def.non_enum_variant();
5436 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5437 (variant.did, tcx.type_of(variant.did))
5440 let mut err = tcx.sess.struct_span_err(span,
5441 "the `Self` constructor can only be used with tuple or unit structs");
5442 if let Some(adt_def) = adt_def {
5443 match adt_def.adt_kind() {
5445 err.help("did you mean to use one of the enum's variants?");
5449 err.span_suggestion(
5451 "use curly brackets",
5452 String::from("Self { /* fields */ }"),
5453 Applicability::HasPlaceholders,
5460 (impl_def_id, tcx.types.err)
5465 let def_id = def.def_id();
5467 // The things we are substituting into the type should not contain
5468 // escaping late-bound regions, and nor should the base type scheme.
5469 let ty = tcx.type_of(def_id);
5474 let substs = AstConv::create_substs_for_generic_args(
5480 // Provide the generic args, and whether types should be inferred.
5482 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5485 // If we've encountered an `impl Trait`-related error, we're just
5486 // going to infer the arguments for better error messages.
5487 if !infer_args_for_err.contains(&index) {
5488 // Check whether the user has provided generic arguments.
5489 if let Some(ref data) = segments[index].args {
5490 return (Some(data), segments[index].infer_types);
5493 return (None, segments[index].infer_types);
5498 // Provide substitutions for parameters for which (valid) arguments have been provided.
5500 match (¶m.kind, arg) {
5501 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5502 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5504 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5505 self.to_ty(ty).into()
5507 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5508 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5510 _ => unreachable!(),
5513 // Provide substitutions for parameters for which arguments are inferred.
5514 |substs, param, infer_types| {
5516 GenericParamDefKind::Lifetime => {
5517 self.re_infer(span, Some(param)).unwrap().into()
5519 GenericParamDefKind::Type { has_default, .. } => {
5520 if !infer_types && has_default {
5521 // If we have a default, then we it doesn't matter that we're not
5522 // inferring the type arguments: we provide the default where any
5524 let default = tcx.type_of(param.def_id);
5527 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5530 // If no type arguments were provided, we have to infer them.
5531 // This case also occurs as a result of some malformed input, e.g.
5532 // a lifetime argument being given instead of a type parameter.
5533 // Using inference instead of `Error` gives better error messages.
5534 self.var_for_def(span, param)
5537 GenericParamDefKind::Const => {
5538 // FIXME(const_generics:defaults)
5539 // No const parameters were provided, we have to infer them.
5540 self.var_for_def(span, param)
5545 assert!(!substs.has_escaping_bound_vars());
5546 assert!(!ty.has_escaping_bound_vars());
5548 // First, store the "user substs" for later.
5549 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5551 // Add all the obligations that are required, substituting and
5552 // normalized appropriately.
5553 let bounds = self.instantiate_bounds(span, def_id, &substs);
5554 self.add_obligations_for_parameters(
5555 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5558 // Substitute the values for the type parameters into the type of
5559 // the referenced item.
5560 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5562 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5563 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5564 // is inherent, there is no `Self` parameter; instead, the impl needs
5565 // type parameters, which we can infer by unifying the provided `Self`
5566 // with the substituted impl type.
5567 // This also occurs for an enum variant on a type alias.
5568 let ty = tcx.type_of(impl_def_id);
5570 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5571 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5572 Ok(ok) => self.register_infer_ok_obligations(ok),
5575 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5582 self.check_rustc_args_require_const(def_id, hir_id, span);
5584 debug!("instantiate_value_path: type of {:?} is {:?}",
5587 self.write_substs(hir_id, substs);
5589 (ty_substituted, new_def)
5592 fn check_rustc_args_require_const(&self,
5596 // We're only interested in functions tagged with
5597 // #[rustc_args_required_const], so ignore anything that's not.
5598 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5602 // If our calling expression is indeed the function itself, we're good!
5603 // If not, generate an error that this can only be called directly.
5604 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5605 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5607 if let ExprKind::Call(ref callee, ..) = expr.node {
5608 if callee.hir_id == hir_id {
5614 self.tcx.sess.span_err(span, "this function can only be invoked \
5615 directly, not through a function pointer");
5618 // Resolves `typ` by a single level if `typ` is a type variable.
5619 // If no resolution is possible, then an error is reported.
5620 // Numeric inference variables may be left unresolved.
5621 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5622 let ty = self.resolve_type_vars_with_obligations(ty);
5623 if !ty.is_ty_var() {
5626 if !self.is_tainted_by_errors() {
5627 self.need_type_info_err((**self).body_id, sp, ty)
5628 .note("type must be known at this point")
5631 self.demand_suptype(sp, self.tcx.types.err, ty);
5636 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5637 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5638 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5641 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5642 index = enclosing_breakables.stack.len();
5643 enclosing_breakables.by_id.insert(id, index);
5644 enclosing_breakables.stack.push(ctxt);
5648 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5649 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5650 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5651 enclosing_breakables.stack.pop().expect("missing breakable context")
5656 /// Instantiate a QueryResponse in a probe context, without a
5657 /// good ObligationCause.
5658 fn probe_instantiate_query_response(
5661 original_values: &OriginalQueryValues<'tcx>,
5662 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5663 ) -> InferResult<'tcx, Ty<'tcx>>
5665 self.instantiate_query_response_and_region_obligations(
5666 &traits::ObligationCause::misc(span, self.body_id),
5672 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5673 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5674 let mut contained_in_place = false;
5676 while let hir::Node::Expr(parent_expr) =
5677 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5679 match &parent_expr.node {
5680 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5681 if lhs.hir_id == expr_id {
5682 contained_in_place = true;
5688 expr_id = parent_expr.hir_id;
5695 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5696 generics: &ty::Generics,
5698 let own_counts = generics.own_counts();
5700 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5706 // FIXME(const_generics): we probably want to check the bounds for const parameters too.
5708 if own_counts.types == 0 {
5712 // Make a vector of booleans initially false, set to true when used.
5713 let mut types_used = vec![false; own_counts.types];
5715 for leaf_ty in ty.walk() {
5716 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5717 debug!("Found use of ty param num {}", idx);
5718 types_used[idx as usize - own_counts.lifetimes] = true;
5719 } else if let ty::Error = leaf_ty.sty {
5720 // If there is already another error, do not emit
5721 // an error for not using a type Parameter.
5722 assert!(tcx.sess.err_count() > 0);
5727 let types = generics.params.iter().filter(|param| match param.kind {
5728 ty::GenericParamDefKind::Type { .. } => true,
5731 for (&used, param) in types_used.iter().zip(types) {
5733 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5734 let span = tcx.hir().span_by_hir_id(id);
5735 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5736 .span_label(span, "unused type parameter")
5742 fn fatally_break_rust(sess: &Session) {
5743 let handler = sess.diagnostic();
5744 handler.span_bug_no_panic(
5746 "It looks like you're trying to break rust; would you like some ICE?",
5748 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5749 handler.note_without_error(
5750 "we would appreciate a joke overview: \
5751 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5753 handler.note_without_error(&format!("rustc {} running on {}",
5754 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5755 crate::session::config::host_triple(),
5759 fn potentially_plural_count(count: usize, word: &str) -> String {
5760 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })