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, Substs, 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_variadic;
134 use crate::session::{CompileIncomplete, 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, NodeMap};
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<NodeMap<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: NodeMap<usize>,
503 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
504 fn find_breakable(&mut self, target_id: ast::NodeId) -> &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 node_id = tcx.hir().as_local_node_id(def_id).unwrap();
597 let hir_id = tcx.hir().definitions().node_to_hir_id(node_id);
598 DefId::local(hir_id.owner)
604 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
610 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
611 fn enter<F, R>(&'tcx mut self, f: F) -> R
612 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
614 let def_id = self.def_id;
615 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
619 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
620 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
622 let item_id = tcx.hir().as_local_node_id(def_id);
623 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
624 let implicit_region_bound = body_id.map(|body_id| {
625 let body = tcx.hir().body(body_id);
626 tcx.mk_region(ty::ReScope(region::Scope {
627 id: body.value.hir_id.local_id,
628 data: region::ScopeData::CallSite
633 tables: MaybeInProgressTables {
634 maybe_tables: infcx.in_progress_tables,
637 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
638 locals: RefCell::new(Default::default()),
639 deferred_sized_obligations: RefCell::new(Vec::new()),
640 deferred_call_resolutions: RefCell::new(Default::default()),
641 deferred_cast_checks: RefCell::new(Vec::new()),
642 deferred_generator_interiors: RefCell::new(Vec::new()),
643 opaque_types: RefCell::new(Default::default()),
644 implicit_region_bound,
649 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
650 debug!("register_predicate({:?})", obligation);
651 if obligation.has_escaping_bound_vars() {
652 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
657 .register_predicate_obligation(self, obligation);
660 fn register_predicates<I>(&self, obligations: I)
661 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
663 for obligation in obligations {
664 self.register_predicate(obligation);
668 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
669 self.register_predicates(infer_ok.obligations);
673 fn normalize_associated_types_in<T>(&self,
676 param_env: ty::ParamEnv<'tcx>,
678 where T : TypeFoldable<'tcx>
680 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
681 self.register_infer_ok_obligations(ok)
685 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
687 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
688 fn visit_item(&mut self, i: &'tcx hir::Item) {
689 check_item_type(self.tcx, i);
691 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
692 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
695 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
696 tcx.sess.track_errors(|| {
697 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
698 tcx.hir().krate().visit_all_item_likes(&mut visit);
702 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
703 tcx.sess.track_errors(|| {
704 for &module in tcx.hir().krate().modules.keys() {
705 tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
710 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
711 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
714 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
715 tcx.typeck_item_bodies(LOCAL_CRATE)
718 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
719 -> Result<(), CompileIncomplete>
721 debug_assert!(crate_num == LOCAL_CRATE);
722 Ok(tcx.sess.track_errors(|| {
723 tcx.par_body_owners(|body_owner_def_id| {
724 tcx.ensure().typeck_tables_of(body_owner_def_id);
729 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
730 wfcheck::check_item_well_formed(tcx, def_id);
733 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
734 wfcheck::check_trait_item(tcx, def_id);
737 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
738 wfcheck::check_impl_item(tcx, def_id);
741 pub fn provide(providers: &mut Providers) {
742 method::provide(providers);
743 *providers = Providers {
749 check_item_well_formed,
750 check_trait_item_well_formed,
751 check_impl_item_well_formed,
752 check_mod_item_types,
757 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
759 -> Option<ty::Destructor> {
760 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
763 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
764 /// with information about it's body-id and fn-decl (if any). Otherwise,
767 /// If this function returns "some", then `typeck_tables(def_id)` will
768 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
769 /// may not succeed. In some cases where this function returns `None`
770 /// (notably closures), `typeck_tables(def_id)` would wind up
771 /// redirecting to the owning function.
772 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
774 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
776 match tcx.hir().get_by_hir_id(id) {
777 Node::Item(item) => {
779 hir::ItemKind::Const(_, body) |
780 hir::ItemKind::Static(_, _, body) =>
782 hir::ItemKind::Fn(ref decl, .., body) =>
783 Some((body, Some(decl))),
788 Node::TraitItem(item) => {
790 hir::TraitItemKind::Const(_, Some(body)) =>
792 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
793 Some((body, Some(&sig.decl))),
798 Node::ImplItem(item) => {
800 hir::ImplItemKind::Const(_, body) =>
802 hir::ImplItemKind::Method(ref sig, body) =>
803 Some((body, Some(&sig.decl))),
808 Node::AnonConst(constant) => Some((constant.body, None)),
813 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.has_typeck_tables(outer_def_id);
823 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
824 primary_body_of(tcx, id).is_some()
827 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
830 tcx.typeck_tables_of(def_id).used_trait_imports.clone()
833 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
835 -> &'tcx ty::TypeckTables<'tcx> {
836 // Closures' tables come from their outermost function,
837 // as they are part of the same "inference environment".
838 let outer_def_id = tcx.closure_base_def_id(def_id);
839 if outer_def_id != def_id {
840 return tcx.typeck_tables_of(outer_def_id);
843 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
844 let span = tcx.hir().span_by_hir_id(id);
846 // Figure out what primary body this item has.
847 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
848 span_bug!(span, "can't type-check body of {:?}", def_id);
850 let body = tcx.hir().body(body_id);
852 let tables = Inherited::build(tcx, def_id).enter(|inh| {
853 let param_env = tcx.param_env(def_id);
854 let fcx = if let Some(decl) = fn_decl {
855 let fn_sig = tcx.fn_sig(def_id);
857 check_abi(tcx, span, fn_sig.abi());
859 // Compute the fty from point of view of inside the fn.
861 tcx.liberate_late_bound_regions(def_id, &fn_sig);
863 inh.normalize_associated_types_in(body.value.span,
868 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
871 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
872 let expected_type = tcx.type_of(def_id);
873 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
874 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
876 let revealed_ty = if tcx.features().impl_trait_in_bindings {
877 fcx.instantiate_opaque_types_from_value(
885 // Gather locals in statics (because of block expressions).
886 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
888 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
893 // All type checking constraints were added, try to fallback unsolved variables.
894 fcx.select_obligations_where_possible(false);
895 let mut fallback_has_occurred = false;
896 for ty in &fcx.unsolved_variables() {
897 fallback_has_occurred |= fcx.fallback_if_possible(ty);
899 fcx.select_obligations_where_possible(fallback_has_occurred);
901 // Even though coercion casts provide type hints, we check casts after fallback for
902 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
905 // Closure and generator analysis may run after fallback
906 // because they don't constrain other type variables.
907 fcx.closure_analyze(body);
908 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
909 fcx.resolve_generator_interiors(def_id);
911 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
912 let ty = fcx.normalize_ty(span, ty);
913 fcx.require_type_is_sized(ty, span, code);
915 fcx.select_all_obligations_or_error();
917 if fn_decl.is_some() {
918 fcx.regionck_fn(id, body);
920 fcx.regionck_expr(body);
923 fcx.resolve_type_vars_in_body(body)
926 // Consistency check our TypeckTables instance can hold all ItemLocalIds
927 // it will need to hold.
928 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
933 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
934 if !tcx.sess.target.target.is_abi_supported(abi) {
935 struct_span_err!(tcx.sess, span, E0570,
936 "The ABI `{}` is not supported for the current target", abi).emit()
940 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
941 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
942 parent_id: hir::HirId,
945 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
946 fn assign(&mut self, span: Span, nid: ast::NodeId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
949 // infer the variable's type
950 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
951 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
958 // take type that the user specified
959 self.fcx.locals.borrow_mut().insert(nid, typ);
966 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
967 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
968 NestedVisitorMap::None
971 // Add explicitly-declared locals.
972 fn visit_local(&mut self, local: &'gcx hir::Local) {
973 let local_ty = match local.ty {
975 let o_ty = self.fcx.to_ty(&ty);
977 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
978 self.fcx.instantiate_opaque_types_from_value(
986 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
987 &UserType::Ty(revealed_ty)
989 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
990 ty.hir_id, o_ty, revealed_ty, c_ty);
991 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
993 Some(LocalTy { decl_ty: o_ty, revealed_ty })
997 self.assign(local.span, local.id, local_ty);
999 debug!("Local variable {:?} is assigned type {}",
1001 self.fcx.ty_to_string(
1002 self.fcx.locals.borrow().get(&local.id).unwrap().clone().decl_ty));
1003 intravisit::walk_local(self, local);
1006 // Add pattern bindings.
1007 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1008 if let PatKind::Binding(_, _, _, ident, _) = p.node {
1009 let var_ty = self.assign(p.span, p.id, None);
1011 if !self.fcx.tcx.features().unsized_locals {
1012 self.fcx.require_type_is_sized(var_ty, p.span,
1013 traits::VariableType(p.id));
1016 debug!("Pattern binding {} is assigned to {} with type {:?}",
1018 self.fcx.ty_to_string(
1019 self.fcx.locals.borrow().get(&p.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(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(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: &'tcx Substs<'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.id={}, it.name={})",
1343 tcx.item_path_str(tcx.hir().local_def_id(it.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(it.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(it.id));
1356 hir::ItemKind::Enum(ref enum_definition, _) => {
1357 check_enum(tcx, it.span, &enum_definition.variants, it.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.id);
1362 let impl_def_id = tcx.hir().local_def_id(it.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(it.id);
1377 check_on_unimplemented(tcx, def_id, it);
1379 hir::ItemKind::Struct(..) => {
1380 check_struct(tcx, it.id, it.span);
1382 hir::ItemKind::Union(..) => {
1383 check_union(tcx, it.id, it.span);
1385 hir::ItemKind::Existential(..) => {
1386 let def_id = tcx.hir().local_def_id(it.id);
1388 let substs = Substs::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(it.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(item.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_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(item.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(tcx.hir().local_def_id(impl_item.id));
1558 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1559 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1560 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1562 // Not compatible, but needed for the error message
1563 tcx.associated_items(impl_trait_ref.def_id)
1564 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1567 // Check that impl definition matches trait definition
1568 if let Some(ty_trait_item) = ty_trait_item {
1569 match impl_item.node {
1570 hir::ImplItemKind::Const(..) => {
1571 // Find associated const definition.
1572 if ty_trait_item.kind == ty::AssociatedKind::Const {
1573 compare_const_impl(tcx,
1579 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1580 "item `{}` is an associated const, \
1581 which doesn't match its trait `{}`",
1584 err.span_label(impl_item.span, "does not match trait");
1585 // We can only get the spans from local trait definition
1586 // Same for E0324 and E0325
1587 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1588 err.span_label(trait_span, "item in trait");
1593 hir::ImplItemKind::Method(..) => {
1594 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1595 if ty_trait_item.kind == ty::AssociatedKind::Method {
1596 compare_impl_method(tcx,
1603 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1604 "item `{}` is an associated method, \
1605 which doesn't match its trait `{}`",
1608 err.span_label(impl_item.span, "does not match trait");
1609 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1610 err.span_label(trait_span, "item in trait");
1615 hir::ImplItemKind::Existential(..) |
1616 hir::ImplItemKind::Type(_) => {
1617 if ty_trait_item.kind == ty::AssociatedKind::Type {
1618 if ty_trait_item.defaultness.has_value() {
1619 overridden_associated_type = Some(impl_item);
1622 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1623 "item `{}` is an associated type, \
1624 which doesn't match its trait `{}`",
1627 err.span_label(impl_item.span, "does not match trait");
1628 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1629 err.span_label(trait_span, "item in trait");
1636 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1640 // Check for missing items from trait
1641 let mut missing_items = Vec::new();
1642 let mut invalidated_items = Vec::new();
1643 let associated_type_overridden = overridden_associated_type.is_some();
1644 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1645 let is_implemented = trait_def.ancestors(tcx, impl_id)
1646 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1648 .map(|node_item| !node_item.node.is_from_trait())
1651 if !is_implemented && !tcx.impl_is_default(impl_id) {
1652 if !trait_item.defaultness.has_value() {
1653 missing_items.push(trait_item);
1654 } else if associated_type_overridden {
1655 invalidated_items.push(trait_item.ident);
1660 if !missing_items.is_empty() {
1661 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1662 "not all trait items implemented, missing: `{}`",
1663 missing_items.iter()
1664 .map(|trait_item| trait_item.ident.to_string())
1665 .collect::<Vec<_>>().join("`, `"));
1666 err.span_label(impl_span, format!("missing `{}` in implementation",
1667 missing_items.iter()
1668 .map(|trait_item| trait_item.ident.to_string())
1669 .collect::<Vec<_>>().join("`, `")));
1670 for trait_item in missing_items {
1671 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1672 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1674 err.note_trait_signature(trait_item.ident.to_string(),
1675 trait_item.signature(&tcx));
1681 if !invalidated_items.is_empty() {
1682 let invalidator = overridden_associated_type.unwrap();
1683 span_err!(tcx.sess, invalidator.span, E0399,
1684 "the following trait items need to be reimplemented \
1685 as `{}` was overridden: `{}`",
1687 invalidated_items.iter()
1688 .map(|name| name.to_string())
1689 .collect::<Vec<_>>().join("`, `"))
1693 /// Checks whether a type can be represented in memory. In particular, it
1694 /// identifies types that contain themselves without indirection through a
1695 /// pointer, which would mean their size is unbounded.
1696 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1700 let rty = tcx.type_of(item_def_id);
1702 // Check that it is possible to represent this type. This call identifies
1703 // (1) types that contain themselves and (2) types that contain a different
1704 // recursive type. It is only necessary to throw an error on those that
1705 // contain themselves. For case 2, there must be an inner type that will be
1706 // caught by case 1.
1707 match rty.is_representable(tcx, sp) {
1708 Representability::SelfRecursive(spans) => {
1709 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1711 err.span_label(span, "recursive without indirection");
1716 Representability::Representable | Representability::ContainsRecursive => (),
1721 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1722 let t = tcx.type_of(def_id);
1723 if let ty::Adt(def, substs) = t.sty {
1724 if def.is_struct() {
1725 let fields = &def.non_enum_variant().fields;
1726 if fields.is_empty() {
1727 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1730 let e = fields[0].ty(tcx, substs);
1731 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1732 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1733 .span_label(sp, "SIMD elements must have the same type")
1738 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1739 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1741 span_err!(tcx.sess, sp, E0077,
1742 "SIMD vector element type should be machine type");
1750 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1751 let repr = tcx.adt_def(def_id).repr;
1753 for attr in tcx.get_attrs(def_id).iter() {
1754 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1755 if let attr::ReprPacked(pack) = r {
1756 if pack != repr.pack {
1757 struct_span_err!(tcx.sess, sp, E0634,
1758 "type has conflicting packed representation hints").emit();
1764 struct_span_err!(tcx.sess, sp, E0587,
1765 "type has conflicting packed and align representation hints").emit();
1767 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1768 struct_span_err!(tcx.sess, sp, E0588,
1769 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1774 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1776 stack: &mut Vec<DefId>) -> bool {
1777 let t = tcx.type_of(def_id);
1778 if stack.contains(&def_id) {
1779 debug!("check_packed_inner: {:?} is recursive", t);
1782 if let ty::Adt(def, substs) = t.sty {
1783 if def.is_struct() || def.is_union() {
1784 if tcx.adt_def(def.did).repr.align > 0 {
1787 // push struct def_id before checking fields
1789 for field in &def.non_enum_variant().fields {
1790 let f = field.ty(tcx, substs);
1791 if let ty::Adt(def, _) = f.sty {
1792 if check_packed_inner(tcx, def.did, stack) {
1797 // only need to pop if not early out
1804 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1805 let adt = tcx.adt_def(def_id);
1806 if !adt.repr.transparent() {
1810 // For each field, figure out if it's known to be a ZST and align(1)
1811 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1812 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1813 let param_env = tcx.param_env(field.did);
1814 let layout = tcx.layout_of(param_env.and(ty));
1815 // We are currently checking the type this field came from, so it must be local
1816 let span = tcx.hir().span_if_local(field.did).unwrap();
1817 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1818 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1822 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1823 let non_zst_count = non_zst_fields.clone().count();
1824 if non_zst_count != 1 {
1825 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1826 struct_span_err!(tcx.sess, sp, E0690,
1827 "transparent struct needs exactly one non-zero-sized field, but has {}",
1829 .span_note(field_spans, "non-zero-sized field")
1832 for (span, zst, align1) in field_infos {
1834 span_err!(tcx.sess, span, E0691,
1835 "zero-sized field in transparent struct has alignment larger than 1");
1840 #[allow(trivial_numeric_casts)]
1841 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1843 vs: &'tcx [hir::Variant],
1845 let def_id = tcx.hir().local_def_id(id);
1846 let def = tcx.adt_def(def_id);
1847 def.destructor(tcx); // force the destructor to be evaluated
1850 let attributes = tcx.get_attrs(def_id);
1851 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1853 tcx.sess, attr.span, E0084,
1854 "unsupported representation for zero-variant enum")
1855 .span_label(sp, "zero-variant enum")
1860 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1861 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1862 if !tcx.features().repr128 {
1863 emit_feature_err(&tcx.sess.parse_sess,
1866 GateIssue::Language,
1867 "repr with 128-bit type is unstable");
1872 if let Some(ref e) = v.node.disr_expr {
1873 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1877 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1878 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1879 // Check for duplicate discriminant values
1880 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1881 let variant_did = def.variants[VariantIdx::new(i)].did;
1882 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1883 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1884 let i_span = match variant_i.node.disr_expr {
1885 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1886 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1888 let span = match v.node.disr_expr {
1889 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1892 struct_span_err!(tcx.sess, span, E0081,
1893 "discriminant value `{}` already exists", disr_vals[i])
1894 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1895 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1898 disr_vals.push(discr);
1901 check_representable(tcx, sp, def_id);
1904 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1908 span_err!(tcx.sess, span, E0533,
1909 "expected unit struct/variant or constant, found {} `{}`",
1911 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1914 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1915 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1917 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1918 -> Lrc<ty::GenericPredicates<'tcx>>
1921 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1922 let item_id = tcx.hir().ty_param_owner(node_id);
1923 let item_def_id = tcx.hir().local_def_id(item_id);
1924 let generics = tcx.generics_of(item_def_id);
1925 let index = generics.param_def_id_to_index[&def_id];
1926 Lrc::new(ty::GenericPredicates {
1928 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1930 ty::Predicate::Trait(ref data)
1931 if data.skip_binder().self_ty().is_param(index) => {
1932 // HACK(eddyb) should get the original `Span`.
1933 let span = tcx.def_span(def_id);
1934 Some((predicate, span))
1942 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1943 -> Option<ty::Region<'tcx>> {
1945 Some(def) => infer::EarlyBoundRegion(span, def.name),
1946 None => infer::MiscVariable(span)
1948 Some(self.next_region_var(v))
1951 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1952 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1955 fn ty_infer_for_def(&self,
1956 ty_param_def: &ty::GenericParamDef,
1957 span: Span) -> Ty<'tcx> {
1958 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1964 fn projected_ty_from_poly_trait_ref(&self,
1967 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1970 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1972 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1976 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1979 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1980 if ty.has_escaping_bound_vars() {
1981 ty // FIXME: normalization and escaping regions
1983 self.normalize_associated_types_in(span, &ty)
1987 fn set_tainted_by_errors(&self) {
1988 self.infcx.set_tainted_by_errors()
1991 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1992 self.write_ty(hir_id, ty)
1996 /// Controls whether the arguments are tupled. This is used for the call
1999 /// Tupling means that all call-side arguments are packed into a tuple and
2000 /// passed as a single parameter. For example, if tupling is enabled, this
2003 /// fn f(x: (isize, isize))
2005 /// Can be called as:
2012 #[derive(Clone, Eq, PartialEq)]
2013 enum TupleArgumentsFlag {
2018 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2019 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2020 param_env: ty::ParamEnv<'tcx>,
2021 body_id: hir::HirId)
2022 -> FnCtxt<'a, 'gcx, 'tcx> {
2026 err_count_on_creation: inh.tcx.sess.err_count(),
2028 ret_coercion_span: RefCell::new(None),
2030 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2031 hir::CRATE_HIR_ID)),
2032 diverges: Cell::new(Diverges::Maybe),
2033 has_errors: Cell::new(false),
2034 enclosing_breakables: RefCell::new(EnclosingBreakables {
2036 by_id: Default::default(),
2042 pub fn sess(&self) -> &Session {
2046 pub fn err_count_since_creation(&self) -> usize {
2047 self.tcx.sess.err_count() - self.err_count_on_creation
2050 /// Produces warning on the given node, if the current point in the
2051 /// function is unreachable, and there hasn't been another warning.
2052 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2053 if self.diverges.get() == Diverges::Always {
2054 self.diverges.set(Diverges::WarnedAlways);
2056 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2058 self.tcx().lint_node(
2059 lint::builtin::UNREACHABLE_CODE,
2061 &format!("unreachable {}", kind));
2067 code: ObligationCauseCode<'tcx>)
2068 -> ObligationCause<'tcx> {
2069 ObligationCause::new(span, self.body_id, code)
2072 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2073 self.cause(span, ObligationCauseCode::MiscObligation)
2076 /// Resolves type variables in `ty` if possible. Unlike the infcx
2077 /// version (resolve_type_vars_if_possible), this version will
2078 /// also select obligations if it seems useful, in an effort
2079 /// to get more type information.
2080 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2081 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2083 // No Infer()? Nothing needs doing.
2084 if !ty.has_infer_types() {
2085 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2089 // If `ty` is a type variable, see whether we already know what it is.
2090 ty = self.resolve_type_vars_if_possible(&ty);
2091 if !ty.has_infer_types() {
2092 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2096 // If not, try resolving pending obligations as much as
2097 // possible. This can help substantially when there are
2098 // indirect dependencies that don't seem worth tracking
2100 self.select_obligations_where_possible(false);
2101 ty = self.resolve_type_vars_if_possible(&ty);
2103 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2107 fn record_deferred_call_resolution(&self,
2108 closure_def_id: DefId,
2109 r: DeferredCallResolution<'gcx, 'tcx>) {
2110 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2111 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2114 fn remove_deferred_call_resolutions(&self,
2115 closure_def_id: DefId)
2116 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2118 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2119 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2122 pub fn tag(&self) -> String {
2123 let self_ptr: *const FnCtxt = self;
2124 format!("{:?}", self_ptr)
2127 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2128 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2129 span_bug!(span, "no type for local variable {}",
2130 self.tcx.hir().node_to_string(nid))
2135 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2136 debug!("write_ty({:?}, {:?}) in fcx {}",
2137 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2138 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2140 if ty.references_error() {
2141 self.has_errors.set(true);
2142 self.set_tainted_by_errors();
2146 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2147 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
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: Substs::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: &'tcx Substs<'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: &'tcx Substs<'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: &Substs<'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: &Substs<'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 // If the type given by the user has free regions, save it for later, since
2440 // NLL would like to enforce those. Also pass in types that involve
2441 // projections, since those can resolve to `'static` bounds (modulo #54940,
2442 // which hopefully will be fixed by the time you see this comment, dear
2443 // reader, although I have my doubts). Also pass in types with inference
2444 // types, because they may be repeated. Other sorts of things are already
2445 // sufficiently enforced with erased regions. =)
2446 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2448 T: TypeFoldable<'tcx>
2450 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2453 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2454 match self.tables.borrow().node_types().get(id) {
2456 None if self.is_tainted_by_errors() => self.tcx.types.err,
2458 let node_id = self.tcx.hir().hir_to_node_id(id);
2459 bug!("no type for node {}: {} in fcx {}",
2460 node_id, self.tcx.hir().node_to_string(node_id),
2466 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2467 /// outlive the region `r`.
2468 pub fn register_wf_obligation(&self,
2471 code: traits::ObligationCauseCode<'tcx>)
2473 // WF obligations never themselves fail, so no real need to give a detailed cause:
2474 let cause = traits::ObligationCause::new(span, self.body_id, code);
2475 self.register_predicate(traits::Obligation::new(cause,
2477 ty::Predicate::WellFormed(ty)));
2480 /// Registers obligations that all types appearing in `substs` are well-formed.
2481 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2482 for ty in substs.types() {
2483 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2487 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2488 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2489 /// trait/region obligations.
2491 /// For example, if there is a function:
2494 /// fn foo<'a,T:'a>(...)
2497 /// and a reference:
2503 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2504 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2505 pub fn add_obligations_for_parameters(&self,
2506 cause: traits::ObligationCause<'tcx>,
2507 predicates: &ty::InstantiatedPredicates<'tcx>)
2509 assert!(!predicates.has_escaping_bound_vars());
2511 debug!("add_obligations_for_parameters(predicates={:?})",
2514 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2515 self.register_predicate(obligation);
2519 // FIXME(arielb1): use this instead of field.ty everywhere
2520 // Only for fields! Returns <none> for methods>
2521 // Indifferent to privacy flags
2522 pub fn field_ty(&self,
2524 field: &'tcx ty::FieldDef,
2525 substs: &Substs<'tcx>)
2528 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2531 fn check_casts(&self) {
2532 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2533 for cast in deferred_cast_checks.drain(..) {
2538 fn resolve_generator_interiors(&self, def_id: DefId) {
2539 let mut generators = self.deferred_generator_interiors.borrow_mut();
2540 for (body_id, interior) in generators.drain(..) {
2541 self.select_obligations_where_possible(false);
2542 generator_interior::resolve_interior(self, def_id, body_id, interior);
2546 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2547 // Non-numerics get replaced with ! or () (depending on whether
2548 // feature(never_type) is enabled, unconstrained ints with i32,
2549 // unconstrained floats with f64.
2550 // Fallback becomes very dubious if we have encountered type-checking errors.
2551 // In that case, fallback to Error.
2552 // The return value indicates whether fallback has occurred.
2553 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2554 use rustc::ty::error::UnconstrainedNumeric::Neither;
2555 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2557 assert!(ty.is_ty_infer());
2558 let fallback = match self.type_is_unconstrained_numeric(ty) {
2559 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2560 UnconstrainedInt => self.tcx.types.i32,
2561 UnconstrainedFloat => self.tcx.types.f64,
2562 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2563 Neither => return false,
2565 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2566 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2570 fn select_all_obligations_or_error(&self) {
2571 debug!("select_all_obligations_or_error");
2572 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2573 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2577 /// Select as many obligations as we can at present.
2578 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2579 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2580 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2584 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2585 /// returns a type of `&T`, but the actual type we assign to the
2586 /// *expression* is `T`. So this function just peels off the return
2587 /// type by one layer to yield `T`.
2588 fn make_overloaded_place_return_type(&self,
2589 method: MethodCallee<'tcx>)
2590 -> ty::TypeAndMut<'tcx>
2592 // extract method return type, which will be &T;
2593 let ret_ty = method.sig.output();
2595 // method returns &T, but the type as visible to user is T, so deref
2596 ret_ty.builtin_deref(true).unwrap()
2599 fn lookup_indexing(&self,
2601 base_expr: &'gcx hir::Expr,
2605 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2607 // FIXME(#18741) -- this is almost but not quite the same as the
2608 // autoderef that normal method probing does. They could likely be
2611 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2612 let mut result = None;
2613 while result.is_none() && autoderef.next().is_some() {
2614 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2616 autoderef.finalize(self);
2620 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2621 /// (and otherwise adjust) `base_expr`, looking for a type which either
2622 /// supports builtin indexing or overloaded indexing.
2623 /// This loop implements one step in that search; the autoderef loop
2624 /// is implemented by `lookup_indexing`.
2625 fn try_index_step(&self,
2627 base_expr: &hir::Expr,
2628 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2631 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2633 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2634 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2641 for &unsize in &[false, true] {
2642 let mut self_ty = adjusted_ty;
2644 // We only unsize arrays here.
2645 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2646 self_ty = self.tcx.mk_slice(element_ty);
2652 // If some lookup succeeds, write callee into table and extract index/element
2653 // type from the method signature.
2654 // If some lookup succeeded, install method in table
2655 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2656 let method = self.try_overloaded_place_op(
2657 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2659 let result = method.map(|ok| {
2660 debug!("try_index_step: success, using overloaded indexing");
2661 let method = self.register_infer_ok_obligations(ok);
2663 let mut adjustments = autoderef.adjust_steps(self, needs);
2664 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2665 let mutbl = match r_mutbl {
2666 hir::MutImmutable => AutoBorrowMutability::Immutable,
2667 hir::MutMutable => AutoBorrowMutability::Mutable {
2668 // Indexing can be desugared to a method call,
2669 // so maybe we could use two-phase here.
2670 // See the documentation of AllowTwoPhase for why that's
2671 // not the case today.
2672 allow_two_phase_borrow: AllowTwoPhase::No,
2675 adjustments.push(Adjustment {
2676 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2677 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2684 adjustments.push(Adjustment {
2685 kind: Adjust::Unsize,
2686 target: method.sig.inputs()[0]
2689 self.apply_adjustments(base_expr, adjustments);
2691 self.write_method_call(expr.hir_id, method);
2692 (input_ty, self.make_overloaded_place_return_type(method).ty)
2694 if result.is_some() {
2702 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2703 let (tr, name) = match (op, is_mut) {
2704 (PlaceOp::Deref, false) =>
2705 (self.tcx.lang_items().deref_trait(), "deref"),
2706 (PlaceOp::Deref, true) =>
2707 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2708 (PlaceOp::Index, false) =>
2709 (self.tcx.lang_items().index_trait(), "index"),
2710 (PlaceOp::Index, true) =>
2711 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2713 (tr, ast::Ident::from_str(name))
2716 fn try_overloaded_place_op(&self,
2719 arg_tys: &[Ty<'tcx>],
2722 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2724 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2730 // Try Mut first, if needed.
2731 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2732 let method = match (needs, mut_tr) {
2733 (Needs::MutPlace, Some(trait_did)) => {
2734 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2739 // Otherwise, fall back to the immutable version.
2740 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2741 let method = match (method, imm_tr) {
2742 (None, Some(trait_did)) => {
2743 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2745 (method, _) => method,
2751 fn check_method_argument_types(&self,
2754 method: Result<MethodCallee<'tcx>, ()>,
2755 args_no_rcvr: &'gcx [hir::Expr],
2756 tuple_arguments: TupleArgumentsFlag,
2757 expected: Expectation<'tcx>)
2759 let has_error = match method {
2761 method.substs.references_error() || method.sig.references_error()
2766 let err_inputs = self.err_args(args_no_rcvr.len());
2768 let err_inputs = match tuple_arguments {
2769 DontTupleArguments => err_inputs,
2770 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2773 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2774 false, tuple_arguments, None);
2775 return self.tcx.types.err;
2778 let method = method.unwrap();
2779 // HACK(eddyb) ignore self in the definition (see above).
2780 let expected_arg_tys = self.expected_inputs_for_expected_output(
2783 method.sig.output(),
2784 &method.sig.inputs()[1..]
2786 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2787 args_no_rcvr, method.sig.variadic, tuple_arguments,
2788 self.tcx.hir().span_if_local(method.def_id));
2792 fn self_type_matches_expected_vid(
2794 trait_ref: ty::PolyTraitRef<'tcx>,
2795 expected_vid: ty::TyVid,
2797 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2799 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2800 trait_ref, self_ty, expected_vid
2803 ty::Infer(ty::TyVar(found_vid)) => {
2804 // FIXME: consider using `sub_root_var` here so we
2805 // can see through subtyping.
2806 let found_vid = self.root_var(found_vid);
2807 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2808 expected_vid == found_vid
2814 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2815 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2816 + Captures<'gcx> + 'b
2818 // FIXME: consider using `sub_root_var` here so we
2819 // can see through subtyping.
2820 let ty_var_root = self.root_var(self_ty);
2821 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2822 self_ty, ty_var_root,
2823 self.fulfillment_cx.borrow().pending_obligations());
2827 .pending_obligations()
2829 .filter_map(move |obligation| match obligation.predicate {
2830 ty::Predicate::Projection(ref data) =>
2831 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2832 ty::Predicate::Trait(ref data) =>
2833 Some((data.to_poly_trait_ref(), obligation)),
2834 ty::Predicate::Subtype(..) => None,
2835 ty::Predicate::RegionOutlives(..) => None,
2836 ty::Predicate::TypeOutlives(..) => None,
2837 ty::Predicate::WellFormed(..) => None,
2838 ty::Predicate::ObjectSafe(..) => None,
2839 ty::Predicate::ConstEvaluatable(..) => None,
2840 // N.B., this predicate is created by breaking down a
2841 // `ClosureType: FnFoo()` predicate, where
2842 // `ClosureType` represents some `Closure`. It can't
2843 // possibly be referring to the current closure,
2844 // because we haven't produced the `Closure` for
2845 // this closure yet; this is exactly why the other
2846 // code is looking for a self type of a unresolved
2847 // inference variable.
2848 ty::Predicate::ClosureKind(..) => None,
2849 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2852 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2853 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2854 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2858 /// Generic function that factors out common logic from function calls,
2859 /// method calls and overloaded operators.
2860 fn check_argument_types(&self,
2863 fn_inputs: &[Ty<'tcx>],
2864 mut expected_arg_tys: &[Ty<'tcx>],
2865 args: &'gcx [hir::Expr],
2867 tuple_arguments: TupleArgumentsFlag,
2868 def_span: Option<Span>) {
2871 // Grab the argument types, supplying fresh type variables
2872 // if the wrong number of arguments were supplied
2873 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2879 // All the input types from the fn signature must outlive the call
2880 // so as to validate implied bounds.
2881 for &fn_input_ty in fn_inputs {
2882 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2885 let expected_arg_count = fn_inputs.len();
2887 let param_count_error = |expected_count: usize,
2892 let mut err = tcx.sess.struct_span_err_with_code(sp,
2893 &format!("this function takes {}{} but {} {} supplied",
2894 if variadic {"at least "} else {""},
2895 potentially_plural_count(expected_count, "parameter"),
2896 potentially_plural_count(arg_count, "parameter"),
2897 if arg_count == 1 {"was"} else {"were"}),
2898 DiagnosticId::Error(error_code.to_owned()));
2900 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2901 err.span_label(def_s, "defined here");
2904 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2905 // remove closing `)` from the span
2906 let sugg_span = sugg_span.shrink_to_lo();
2907 err.span_suggestion(
2909 "expected the unit value `()`; create it with empty parentheses",
2911 Applicability::MachineApplicable);
2913 err.span_label(sp, format!("expected {}{}",
2914 if variadic {"at least "} else {""},
2915 potentially_plural_count(expected_count, "parameter")));
2920 let formal_tys = if tuple_arguments == TupleArguments {
2921 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2922 match tuple_type.sty {
2923 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2924 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2925 expected_arg_tys = &[];
2926 self.err_args(args.len())
2928 ty::Tuple(arg_types) => {
2929 expected_arg_tys = match expected_arg_tys.get(0) {
2930 Some(&ty) => match ty.sty {
2931 ty::Tuple(ref tys) => &tys,
2939 span_err!(tcx.sess, sp, E0059,
2940 "cannot use call notation; the first type parameter \
2941 for the function trait is neither a tuple nor unit");
2942 expected_arg_tys = &[];
2943 self.err_args(args.len())
2946 } else if expected_arg_count == supplied_arg_count {
2948 } else if variadic {
2949 if supplied_arg_count >= expected_arg_count {
2952 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2953 expected_arg_tys = &[];
2954 self.err_args(supplied_arg_count)
2957 // is the missing argument of type `()`?
2958 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2959 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2960 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2961 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2965 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2967 expected_arg_tys = &[];
2968 self.err_args(supplied_arg_count)
2970 // If there is no expectation, expect formal_tys.
2971 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2977 debug!("check_argument_types: formal_tys={:?}",
2978 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2980 // Check the arguments.
2981 // We do this in a pretty awful way: first we type-check any arguments
2982 // that are not closures, then we type-check the closures. This is so
2983 // that we have more information about the types of arguments when we
2984 // type-check the functions. This isn't really the right way to do this.
2985 for &check_closures in &[false, true] {
2986 debug!("check_closures={}", check_closures);
2988 // More awful hacks: before we check argument types, try to do
2989 // an "opportunistic" vtable resolution of any trait bounds on
2990 // the call. This helps coercions.
2992 self.select_obligations_where_possible(false);
2995 // For variadic functions, we don't have a declared type for all of
2996 // the arguments hence we only do our usual type checking with
2997 // the arguments who's types we do know.
2998 let t = if variadic {
3000 } else if tuple_arguments == TupleArguments {
3005 for (i, arg) in args.iter().take(t).enumerate() {
3006 // Warn only for the first loop (the "no closures" one).
3007 // Closure arguments themselves can't be diverging, but
3008 // a previous argument can, e.g., `foo(panic!(), || {})`.
3009 if !check_closures {
3010 self.warn_if_unreachable(arg.id, arg.span, "expression");
3013 let is_closure = match arg.node {
3014 ExprKind::Closure(..) => true,
3018 if is_closure != check_closures {
3022 debug!("checking the argument");
3023 let formal_ty = formal_tys[i];
3025 // The special-cased logic below has three functions:
3026 // 1. Provide as good of an expected type as possible.
3027 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3029 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3031 // 2. Coerce to the most detailed type that could be coerced
3032 // to, which is `expected_ty` if `rvalue_hint` returns an
3033 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3034 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3035 // We're processing function arguments so we definitely want to use
3036 // two-phase borrows.
3037 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3039 // 3. Relate the expected type and the formal one,
3040 // if the expected type was used for the coercion.
3041 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3045 // We also need to make sure we at least write the ty of the other
3046 // arguments which we skipped above.
3048 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3049 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3050 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3053 for arg in args.iter().skip(expected_arg_count) {
3054 let arg_ty = self.check_expr(&arg);
3056 // There are a few types which get autopromoted when passed via varargs
3057 // in C but we just error out instead and require explicit casts.
3058 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3060 ty::Float(ast::FloatTy::F32) => {
3061 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3063 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3064 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3066 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3067 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3070 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3071 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3072 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3080 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3081 vec![self.tcx.types.err; len]
3084 // AST fragment checking
3087 expected: Expectation<'tcx>)
3093 ast::LitKind::Str(..) => tcx.mk_static_str(),
3094 ast::LitKind::ByteStr(ref v) => {
3095 tcx.mk_imm_ref(tcx.types.re_static,
3096 tcx.mk_array(tcx.types.u8, v.len() as u64))
3098 ast::LitKind::Byte(_) => tcx.types.u8,
3099 ast::LitKind::Char(_) => tcx.types.char,
3100 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3101 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3102 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3103 let opt_ty = expected.to_option(self).and_then(|ty| {
3105 ty::Int(_) | ty::Uint(_) => Some(ty),
3106 ty::Char => Some(tcx.types.u8),
3107 ty::RawPtr(..) => Some(tcx.types.usize),
3108 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3112 opt_ty.unwrap_or_else(
3113 || tcx.mk_int_var(self.next_int_var_id()))
3115 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3116 ast::LitKind::FloatUnsuffixed(_) => {
3117 let opt_ty = expected.to_option(self).and_then(|ty| {
3119 ty::Float(_) => Some(ty),
3123 opt_ty.unwrap_or_else(
3124 || tcx.mk_float_var(self.next_float_var_id()))
3126 ast::LitKind::Bool(_) => tcx.types.bool,
3127 ast::LitKind::Err(_) => tcx.types.err,
3131 fn check_expr_eq_type(&self,
3132 expr: &'gcx hir::Expr,
3133 expected: Ty<'tcx>) {
3134 let ty = self.check_expr_with_hint(expr, expected);
3135 self.demand_eqtype(expr.span, expected, ty);
3138 pub fn check_expr_has_type_or_error(&self,
3139 expr: &'gcx hir::Expr,
3140 expected: Ty<'tcx>) -> Ty<'tcx> {
3141 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3144 fn check_expr_meets_expectation_or_error(&self,
3145 expr: &'gcx hir::Expr,
3146 expected: Expectation<'tcx>) -> Ty<'tcx> {
3147 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3148 let mut ty = self.check_expr_with_expectation(expr, expected);
3150 // While we don't allow *arbitrary* coercions here, we *do* allow
3151 // coercions from ! to `expected`.
3153 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3154 "expression with never type wound up being adjusted");
3155 let adj_ty = self.next_diverging_ty_var(
3156 TypeVariableOrigin::AdjustmentType(expr.span));
3157 self.apply_adjustments(expr, vec![Adjustment {
3158 kind: Adjust::NeverToAny,
3164 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3165 // Add help to type error if this is an `if` condition with an assignment.
3166 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3167 = (expected, &expr.node)
3169 let msg = "try comparing for equality";
3170 if let (Ok(left), Ok(right)) = (
3171 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3172 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3174 err.span_suggestion(
3177 format!("{} == {}", left, right),
3178 Applicability::MaybeIncorrect);
3188 fn check_expr_coercable_to_type(&self,
3189 expr: &'gcx hir::Expr,
3190 expected: Ty<'tcx>) -> Ty<'tcx> {
3191 let ty = self.check_expr_with_hint(expr, expected);
3192 // checks don't need two phase
3193 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3196 fn check_expr_with_hint(&self,
3197 expr: &'gcx hir::Expr,
3198 expected: Ty<'tcx>) -> Ty<'tcx> {
3199 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3202 fn check_expr_with_expectation(&self,
3203 expr: &'gcx hir::Expr,
3204 expected: Expectation<'tcx>) -> Ty<'tcx> {
3205 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3208 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3209 self.check_expr_with_expectation(expr, NoExpectation)
3212 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3213 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3216 // Determine the `Self` type, using fresh variables for all variables
3217 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3218 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3220 pub fn impl_self_ty(&self,
3221 span: Span, // (potential) receiver for this impl
3223 -> TypeAndSubsts<'tcx> {
3224 let ity = self.tcx.type_of(did);
3225 debug!("impl_self_ty: ity={:?}", ity);
3227 let substs = self.fresh_substs_for_item(span, did);
3228 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3230 TypeAndSubsts { substs: substs, ty: substd_ty }
3233 /// Unifies the output type with the expected type early, for more coercions
3234 /// and forward type information on the input expressions.
3235 fn expected_inputs_for_expected_output(&self,
3237 expected_ret: Expectation<'tcx>,
3238 formal_ret: Ty<'tcx>,
3239 formal_args: &[Ty<'tcx>])
3241 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3242 let ret_ty = match expected_ret.only_has_type(self) {
3244 None => return Vec::new()
3246 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3247 // Attempt to apply a subtyping relationship between the formal
3248 // return type (likely containing type variables if the function
3249 // is polymorphic) and the expected return type.
3250 // No argument expectations are produced if unification fails.
3251 let origin = self.misc(call_span);
3252 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3254 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3255 // to identity so the resulting type is not constrained.
3258 // Process any obligations locally as much as
3259 // we can. We don't care if some things turn
3260 // out unconstrained or ambiguous, as we're
3261 // just trying to get hints here.
3262 self.save_and_restore_in_snapshot_flag(|_| {
3263 let mut fulfill = TraitEngine::new(self.tcx);
3264 for obligation in ok.obligations {
3265 fulfill.register_predicate_obligation(self, obligation);
3267 fulfill.select_where_possible(self)
3268 }).map_err(|_| ())?;
3270 Err(_) => return Err(()),
3273 // Record all the argument types, with the substitutions
3274 // produced from the above subtyping unification.
3275 Ok(formal_args.iter().map(|ty| {
3276 self.resolve_type_vars_if_possible(ty)
3278 }).unwrap_or_default();
3279 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3280 formal_args, formal_ret,
3281 expect_args, expected_ret);
3285 // Checks a method call.
3286 fn check_method_call(&self,
3287 expr: &'gcx hir::Expr,
3288 segment: &hir::PathSegment,
3290 args: &'gcx [hir::Expr],
3291 expected: Expectation<'tcx>,
3292 needs: Needs) -> Ty<'tcx> {
3293 let rcvr = &args[0];
3294 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3295 // no need to check for bot/err -- callee does that
3296 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3298 let method = match self.lookup_method(rcvr_t,
3304 self.write_method_call(expr.hir_id, method);
3308 if segment.ident.name != keywords::Invalid.name() {
3309 self.report_method_error(span,
3312 SelfSource::MethodCall(rcvr),
3320 // Call the generic checker.
3321 self.check_method_argument_types(span,
3329 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3333 .unwrap_or_else(|| span_bug!(return_expr.span,
3334 "check_return_expr called outside fn body"));
3336 let ret_ty = ret_coercion.borrow().expected_ty();
3337 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3338 ret_coercion.borrow_mut()
3340 &self.cause(return_expr.span,
3341 ObligationCauseCode::ReturnType(return_expr.id)),
3346 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3347 // or 'if-else' expression.
3348 fn check_then_else(&self,
3349 cond_expr: &'gcx hir::Expr,
3350 then_expr: &'gcx hir::Expr,
3351 opt_else_expr: Option<&'gcx hir::Expr>,
3353 expected: Expectation<'tcx>) -> Ty<'tcx> {
3354 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3355 let cond_diverges = self.diverges.get();
3356 self.diverges.set(Diverges::Maybe);
3358 let expected = expected.adjust_for_branches(self);
3359 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3360 let then_diverges = self.diverges.get();
3361 self.diverges.set(Diverges::Maybe);
3363 // We've already taken the expected type's preferences
3364 // into account when typing the `then` branch. To figure
3365 // out the initial shot at a LUB, we thus only consider
3366 // `expected` if it represents a *hard* constraint
3367 // (`only_has_type`); otherwise, we just go with a
3368 // fresh type variable.
3369 let coerce_to_ty = expected.coercion_target_type(self, sp);
3370 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3372 coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
3374 if let Some(else_expr) = opt_else_expr {
3375 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3376 let else_diverges = self.diverges.get();
3378 let mut outer_sp = if self.tcx.sess.source_map().is_multiline(sp) {
3379 // The `if`/`else` isn't in one line in the output, include some context to make it
3380 // clear it is an if/else expression:
3382 // LL | let x = if true {
3385 // || ----- expected because of this
3388 // || ^^^^^ expected i32, found u32
3390 // ||_____- if and else have incompatible types
3394 // The entire expression is in one line, only point at the arms
3396 // LL | let x = if true { 10i32 } else { 10u32 };
3397 // | ----- ^^^^^ expected i32, found u32
3399 // | expected because of this
3403 let mut remove_semicolon = None;
3404 let error_sp = if let ExprKind::Block(block, _) = &else_expr.node {
3405 if let Some(expr) = &block.expr {
3407 } else if let Some(stmt) = block.stmts.last() {
3408 // possibly incorrect trailing `;` in the else arm
3409 remove_semicolon = self.could_remove_semicolon(block, then_ty);
3411 } else { // empty block, point at its entirety
3412 // Avoid overlapping spans that aren't as readable:
3414 // 2 | let x = if true {
3417 // | | - expected because of this
3424 // | |______if and else have incompatible types
3425 // | expected integer, found ()
3427 // by not pointing at the entire expression:
3429 // 2 | let x = if true {
3430 // | ------- if and else have incompatible types
3432 // | - expected because of this
3437 // | |_____^ expected integer, found ()
3439 if outer_sp.is_some() {
3440 outer_sp = Some(self.tcx.sess.source_map().def_span(sp));
3444 } else { // shouldn't happen unless the parser has done something weird
3447 let then_sp = if let ExprKind::Block(block, _) = &then_expr.node {
3448 if let Some(expr) = &block.expr {
3450 } else if let Some(stmt) = block.stmts.last() {
3451 // possibly incorrect trailing `;` in the else arm
3452 remove_semicolon = remove_semicolon.or(
3453 self.could_remove_semicolon(block, else_ty));
3455 } else { // empty block, point at its entirety
3456 outer_sp = None; // same as in `error_sp`, cleanup output
3459 } else { // shouldn't happen unless the parser has done something weird
3463 let if_cause = self.cause(error_sp, ObligationCauseCode::IfExpression {
3466 semicolon: remove_semicolon,
3469 coerce.coerce(self, &if_cause, else_expr, else_ty);
3471 // We won't diverge unless both branches do (or the condition does).
3472 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3474 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3475 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3477 // If the condition is false we can't diverge.
3478 self.diverges.set(cond_diverges);
3481 let result_ty = coerce.complete(self);
3482 if cond_ty.references_error() {
3489 // Check field access expressions
3490 fn check_field(&self,
3491 expr: &'gcx hir::Expr,
3493 base: &'gcx hir::Expr,
3494 field: ast::Ident) -> Ty<'tcx> {
3495 let expr_t = self.check_expr_with_needs(base, needs);
3496 let expr_t = self.structurally_resolved_type(base.span,
3498 let mut private_candidate = None;
3499 let mut autoderef = self.autoderef(expr.span, expr_t);
3500 while let Some((base_t, _)) = autoderef.next() {
3502 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3503 debug!("struct named {:?}", base_t);
3504 let (ident, def_scope) =
3505 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3506 let fields = &base_def.non_enum_variant().fields;
3507 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3508 let field = &fields[index];
3509 let field_ty = self.field_ty(expr.span, field, substs);
3510 // Save the index of all fields regardless of their visibility in case
3511 // of error recovery.
3512 self.write_field_index(expr.id, index);
3513 if field.vis.is_accessible_from(def_scope, self.tcx) {
3514 let adjustments = autoderef.adjust_steps(self, needs);
3515 self.apply_adjustments(base, adjustments);
3516 autoderef.finalize(self);
3518 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3521 private_candidate = Some((base_def.did, field_ty));
3524 ty::Tuple(ref tys) => {
3525 let fstr = field.as_str();
3526 if let Ok(index) = fstr.parse::<usize>() {
3527 if fstr == index.to_string() {
3528 if let Some(field_ty) = tys.get(index) {
3529 let adjustments = autoderef.adjust_steps(self, needs);
3530 self.apply_adjustments(base, adjustments);
3531 autoderef.finalize(self);
3533 self.write_field_index(expr.id, index);
3542 autoderef.unambiguous_final_ty(self);
3544 if let Some((did, field_ty)) = private_candidate {
3545 let struct_path = self.tcx().item_path_str(did);
3546 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3547 "field `{}` of struct `{}` is private",
3548 field, struct_path);
3549 // Also check if an accessible method exists, which is often what is meant.
3550 if self.method_exists(field, expr_t, expr.id, false) && !self.expr_in_place(expr.id) {
3551 self.suggest_method_call(
3553 &format!("a method `{}` also exists, call it with parentheses", field),
3561 } else if field.name == keywords::Invalid.name() {
3562 self.tcx().types.err
3563 } else if self.method_exists(field, expr_t, expr.id, true) {
3564 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3565 "attempted to take value of method `{}` on type `{}`",
3568 if !self.expr_in_place(expr.id) {
3569 self.suggest_method_call(
3571 "use parentheses to call the method",
3577 err.help("methods are immutable and cannot be assigned to");
3581 self.tcx().types.err
3583 if !expr_t.is_primitive_ty() {
3584 let mut err = self.no_such_field_err(field.span, field, expr_t);
3587 ty::Adt(def, _) if !def.is_enum() => {
3588 if let Some(suggested_field_name) =
3589 Self::suggest_field_name(def.non_enum_variant(),
3590 &field.as_str(), vec![]) {
3591 err.span_suggestion(
3593 "a field with a similar name exists",
3594 suggested_field_name.to_string(),
3595 Applicability::MaybeIncorrect,
3598 err.span_label(field.span, "unknown field");
3599 let struct_variant_def = def.non_enum_variant();
3600 let field_names = self.available_field_names(struct_variant_def);
3601 if !field_names.is_empty() {
3602 err.note(&format!("available fields are: {}",
3603 self.name_series_display(field_names)));
3607 ty::Array(_, len) => {
3608 if let (Some(len), Ok(user_index)) = (
3609 len.assert_usize(self.tcx),
3610 field.as_str().parse::<u64>()
3612 let base = self.tcx.sess.source_map()
3613 .span_to_snippet(base.span)
3614 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3615 let help = "instead of using tuple indexing, use array indexing";
3616 let suggestion = format!("{}[{}]", base, field);
3617 let applicability = if len < user_index {
3618 Applicability::MachineApplicable
3620 Applicability::MaybeIncorrect
3622 err.span_suggestion(
3623 expr.span, help, suggestion, applicability
3628 let base = self.tcx.sess.source_map()
3629 .span_to_snippet(base.span)
3630 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3631 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3632 let suggestion = format!("(*{}).{}", base, field);
3633 err.span_suggestion(
3637 Applicability::MaybeIncorrect,
3644 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3645 "`{}` is a primitive type and therefore doesn't have fields",
3648 self.tcx().types.err
3652 // Return an hint about the closest match in field names
3653 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3655 skip: Vec<LocalInternedString>)
3657 let names = variant.fields.iter().filter_map(|field| {
3658 // ignore already set fields and private fields from non-local crates
3659 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3660 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3663 Some(&field.ident.name)
3667 find_best_match_for_name(names, field, None)
3670 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3671 variant.fields.iter().filter(|field| {
3672 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3673 field.vis.is_accessible_from(def_scope, self.tcx)
3675 .map(|field| field.ident.name)
3679 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3680 // dynamic limit, to never omit just one field
3681 let limit = if names.len() == 6 { 6 } else { 5 };
3682 let mut display = names.iter().take(limit)
3683 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3684 if names.len() > limit {
3685 display = format!("{} ... and {} others", display, names.len() - limit);
3690 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3691 -> DiagnosticBuilder<'_> {
3692 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3693 "no field `{}` on type `{}`",
3697 fn report_unknown_field(&self,
3699 variant: &'tcx ty::VariantDef,
3701 skip_fields: &[hir::Field],
3703 let mut err = self.type_error_struct_with_diag(
3705 |actual| match ty.sty {
3706 ty::Adt(adt, ..) if adt.is_enum() => {
3707 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3708 "{} `{}::{}` has no field named `{}`",
3709 kind_name, actual, variant.ident, field.ident)
3712 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3713 "{} `{}` has no field named `{}`",
3714 kind_name, actual, field.ident)
3718 // prevent all specified fields from being suggested
3719 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3720 if let Some(field_name) = Self::suggest_field_name(variant,
3721 &field.ident.as_str(),
3722 skip_fields.collect()) {
3723 err.span_suggestion(
3725 "a field with a similar name exists",
3726 field_name.to_string(),
3727 Applicability::MaybeIncorrect,
3731 ty::Adt(adt, ..) => {
3733 err.span_label(field.ident.span,
3734 format!("`{}::{}` does not have this field",
3735 ty, variant.ident));
3737 err.span_label(field.ident.span,
3738 format!("`{}` does not have this field", ty));
3740 let available_field_names = self.available_field_names(variant);
3741 if !available_field_names.is_empty() {
3742 err.note(&format!("available fields are: {}",
3743 self.name_series_display(available_field_names)));
3746 _ => bug!("non-ADT passed to report_unknown_field")
3752 fn check_expr_struct_fields(&self,
3754 expected: Expectation<'tcx>,
3755 expr_id: ast::NodeId,
3757 variant: &'tcx ty::VariantDef,
3758 ast_fields: &'gcx [hir::Field],
3759 check_completeness: bool) -> bool {
3763 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3764 .get(0).cloned().unwrap_or(adt_ty);
3765 // re-link the regions that EIfEO can erase.
3766 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3768 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3769 &ty::Adt(adt, substs) => {
3770 (substs, adt.adt_kind(), adt.variant_descr())
3772 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3775 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3776 (field.ident.modern(), (i, field))
3777 ).collect::<FxHashMap<_, _>>();
3779 let mut seen_fields = FxHashMap::default();
3781 let mut error_happened = false;
3783 // Type-check each field.
3784 for field in ast_fields {
3785 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3786 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3787 seen_fields.insert(ident, field.span);
3788 self.write_field_index(field.id, i);
3790 // We don't look at stability attributes on
3791 // struct-like enums (yet...), but it's definitely not
3792 // a bug to have constructed one.
3793 if adt_kind != AdtKind::Enum {
3794 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3797 self.field_ty(field.span, v_field, substs)
3799 error_happened = true;
3800 if let Some(prev_span) = seen_fields.get(&ident) {
3801 let mut err = struct_span_err!(self.tcx.sess,
3804 "field `{}` specified more than once",
3807 err.span_label(field.ident.span, "used more than once");
3808 err.span_label(*prev_span, format!("first use of `{}`", ident));
3812 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3818 // Make sure to give a type to the field even if there's
3819 // an error, so we can continue type-checking.
3820 self.check_expr_coercable_to_type(&field.expr, field_type);
3823 // Make sure the programmer specified correct number of fields.
3824 if kind_name == "union" {
3825 if ast_fields.len() != 1 {
3826 tcx.sess.span_err(span, "union expressions should have exactly one field");
3828 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3829 let len = remaining_fields.len();
3831 let mut displayable_field_names = remaining_fields
3833 .map(|ident| ident.as_str())
3834 .collect::<Vec<_>>();
3836 displayable_field_names.sort();
3838 let truncated_fields_error = if len <= 3 {
3841 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3844 let remaining_fields_names = displayable_field_names.iter().take(3)
3845 .map(|n| format!("`{}`", n))
3846 .collect::<Vec<_>>()
3849 struct_span_err!(tcx.sess, span, E0063,
3850 "missing field{} {}{} in initializer of `{}`",
3851 if remaining_fields.len() == 1 { "" } else { "s" },
3852 remaining_fields_names,
3853 truncated_fields_error,
3855 .span_label(span, format!("missing {}{}",
3856 remaining_fields_names,
3857 truncated_fields_error))
3863 fn check_struct_fields_on_error(&self,
3864 fields: &'gcx [hir::Field],
3865 base_expr: &'gcx Option<P<hir::Expr>>) {
3866 for field in fields {
3867 self.check_expr(&field.expr);
3869 if let Some(ref base) = *base_expr {
3870 self.check_expr(&base);
3874 pub fn check_struct_path(&self,
3876 node_id: ast::NodeId)
3877 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3878 let path_span = match *qpath {
3879 QPath::Resolved(_, ref path) => path.span,
3880 QPath::TypeRelative(ref qself, _) => qself.span
3882 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3883 let variant = match def {
3885 self.set_tainted_by_errors();
3888 Def::Variant(..) => {
3890 ty::Adt(adt, substs) => {
3891 Some((adt.variant_of_def(def), adt.did, substs))
3893 _ => bug!("unexpected type: {:?}", ty.sty)
3896 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3897 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3899 ty::Adt(adt, substs) if !adt.is_enum() => {
3900 Some((adt.non_enum_variant(), adt.did, substs))
3905 _ => bug!("unexpected definition: {:?}", def)
3908 if let Some((variant, did, substs)) = variant {
3909 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3910 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3911 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3913 // Check bounds on type arguments used in the path.
3914 let bounds = self.instantiate_bounds(path_span, did, substs);
3915 let cause = traits::ObligationCause::new(path_span, self.body_id,
3916 traits::ItemObligation(did));
3917 self.add_obligations_for_parameters(cause, &bounds);
3921 struct_span_err!(self.tcx.sess, path_span, E0071,
3922 "expected struct, variant or union type, found {}",
3923 ty.sort_string(self.tcx))
3924 .span_label(path_span, "not a struct")
3930 fn check_expr_struct(&self,
3932 expected: Expectation<'tcx>,
3934 fields: &'gcx [hir::Field],
3935 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3937 // Find the relevant variant
3938 let (variant, adt_ty) =
3939 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3942 self.check_struct_fields_on_error(fields, base_expr);
3943 return self.tcx.types.err;
3946 let path_span = match *qpath {
3947 QPath::Resolved(_, ref path) => path.span,
3948 QPath::TypeRelative(ref qself, _) => qself.span
3951 // Prohibit struct expressions when non-exhaustive flag is set.
3952 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3953 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3954 span_err!(self.tcx.sess, expr.span, E0639,
3955 "cannot create non-exhaustive {} using struct expression",
3956 adt.variant_descr());
3959 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3960 variant, fields, base_expr.is_none());
3961 if let &Some(ref base_expr) = base_expr {
3962 // If check_expr_struct_fields hit an error, do not attempt to populate
3963 // the fields with the base_expr. This could cause us to hit errors later
3964 // when certain fields are assumed to exist that in fact do not.
3965 if !error_happened {
3966 self.check_expr_has_type_or_error(base_expr, adt_ty);
3968 ty::Adt(adt, substs) if adt.is_struct() => {
3969 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3970 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3975 .fru_field_types_mut()
3976 .insert(expr.hir_id, fru_field_types);
3979 span_err!(self.tcx.sess, base_expr.span, E0436,
3980 "functional record update syntax requires a struct");
3985 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3991 /// If an expression has any sub-expressions that result in a type error,
3992 /// inspecting that expression's type with `ty.references_error()` will return
3993 /// true. Likewise, if an expression is known to diverge, inspecting its
3994 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3995 /// strict, _|_ can appear in the type of an expression that does not,
3996 /// itself, diverge: for example, fn() -> _|_.)
3997 /// Note that inspecting a type's structure *directly* may expose the fact
3998 /// that there are actually multiple representations for `Error`, so avoid
3999 /// that when err needs to be handled differently.
4000 fn check_expr_with_expectation_and_needs(&self,
4001 expr: &'gcx hir::Expr,
4002 expected: Expectation<'tcx>,
4003 needs: Needs) -> Ty<'tcx> {
4004 debug!(">> type-checking: expr={:?} expected={:?}",
4007 // Warn for expressions after diverging siblings.
4008 self.warn_if_unreachable(expr.id, expr.span, "expression");
4010 // Hide the outer diverging and has_errors flags.
4011 let old_diverges = self.diverges.get();
4012 let old_has_errors = self.has_errors.get();
4013 self.diverges.set(Diverges::Maybe);
4014 self.has_errors.set(false);
4016 let ty = self.check_expr_kind(expr, expected, needs);
4018 // Warn for non-block expressions with diverging children.
4020 ExprKind::Block(..) |
4021 ExprKind::Loop(..) | ExprKind::While(..) |
4022 ExprKind::If(..) | ExprKind::Match(..) => {}
4024 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
4027 // Any expression that produces a value of type `!` must have diverged
4029 self.diverges.set(self.diverges.get() | Diverges::Always);
4032 // Record the type, which applies it effects.
4033 // We need to do this after the warning above, so that
4034 // we don't warn for the diverging expression itself.
4035 self.write_ty(expr.hir_id, ty);
4037 // Combine the diverging and has_error flags.
4038 self.diverges.set(self.diverges.get() | old_diverges);
4039 self.has_errors.set(self.has_errors.get() | old_has_errors);
4041 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
4042 debug!("... {:?}, expected is {:?}", ty, expected);
4049 expr: &'gcx hir::Expr,
4050 expected: Expectation<'tcx>,
4054 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
4063 ExprKind::Box(ref subexpr) => {
4064 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
4066 ty::Adt(def, _) if def.is_box()
4067 => Expectation::rvalue_hint(self, ty.boxed_ty()),
4071 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
4072 tcx.mk_box(referent_ty)
4075 ExprKind::Lit(ref lit) => {
4076 self.check_lit(&lit, expected)
4078 ExprKind::Binary(op, ref lhs, ref rhs) => {
4079 self.check_binop(expr, op, lhs, rhs)
4081 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
4082 self.check_binop_assign(expr, op, lhs, rhs)
4084 ExprKind::Unary(unop, ref oprnd) => {
4085 let expected_inner = match unop {
4086 hir::UnNot | hir::UnNeg => {
4093 let needs = match unop {
4094 hir::UnDeref => needs,
4097 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
4101 if !oprnd_t.references_error() {
4102 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
4105 if let Some(mt) = oprnd_t.builtin_deref(true) {
4107 } else if let Some(ok) = self.try_overloaded_deref(
4108 expr.span, oprnd_t, needs) {
4109 let method = self.register_infer_ok_obligations(ok);
4110 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
4111 let mutbl = match mutbl {
4112 hir::MutImmutable => AutoBorrowMutability::Immutable,
4113 hir::MutMutable => AutoBorrowMutability::Mutable {
4114 // (It shouldn't actually matter for unary ops whether
4115 // we enable two-phase borrows or not, since a unary
4116 // op has no additional operands.)
4117 allow_two_phase_borrow: AllowTwoPhase::No,
4120 self.apply_adjustments(oprnd, vec![Adjustment {
4121 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4122 target: method.sig.inputs()[0]
4125 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4126 self.write_method_call(expr.hir_id, method);
4128 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
4129 "type `{}` cannot be dereferenced",
4131 oprnd_t = tcx.types.err;
4135 let result = self.check_user_unop(expr, oprnd_t, unop);
4136 // If it's builtin, we can reuse the type, this helps inference.
4137 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4142 let result = self.check_user_unop(expr, oprnd_t, unop);
4143 // If it's builtin, we can reuse the type, this helps inference.
4144 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4152 ExprKind::AddrOf(mutbl, ref oprnd) => {
4153 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4155 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4156 if oprnd.is_place_expr() {
4157 // Places may legitimately have unsized types.
4158 // For example, dereferences of a fat pointer and
4159 // the last field of a struct can be unsized.
4162 Expectation::rvalue_hint(self, ty)
4168 let needs = Needs::maybe_mut_place(mutbl);
4169 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4171 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4172 if tm.ty.references_error() {
4175 // Note: at this point, we cannot say what the best lifetime
4176 // is to use for resulting pointer. We want to use the
4177 // shortest lifetime possible so as to avoid spurious borrowck
4178 // errors. Moreover, the longest lifetime will depend on the
4179 // precise details of the value whose address is being taken
4180 // (and how long it is valid), which we don't know yet until type
4181 // inference is complete.
4183 // Therefore, here we simply generate a region variable. The
4184 // region inferencer will then select the ultimate value.
4185 // Finally, borrowck is charged with guaranteeing that the
4186 // value whose address was taken can actually be made to live
4187 // as long as it needs to live.
4188 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4189 tcx.mk_ref(region, tm)
4192 ExprKind::Path(ref qpath) => {
4193 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4194 let ty = match def {
4196 self.set_tainted_by_errors();
4199 Def::VariantCtor(_, CtorKind::Fictive) => {
4200 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4203 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4206 if let ty::FnDef(..) = ty.sty {
4207 let fn_sig = ty.fn_sig(tcx);
4208 if !tcx.features().unsized_locals {
4209 // We want to remove some Sized bounds from std functions,
4210 // but don't want to expose the removal to stable Rust.
4211 // i.e., we don't want to allow
4217 // to work in stable even if the Sized bound on `drop` is relaxed.
4218 for i in 0..fn_sig.inputs().skip_binder().len() {
4219 // We just want to check sizedness, so instead of introducing
4220 // placeholder lifetimes with probing, we just replace higher lifetimes
4222 let input = self.replace_bound_vars_with_fresh_vars(
4224 infer::LateBoundRegionConversionTime::FnCall,
4225 &fn_sig.input(i)).0;
4226 self.require_type_is_sized_deferred(input, expr.span,
4227 traits::SizedArgumentType);
4230 // Here we want to prevent struct constructors from returning unsized types.
4231 // There were two cases this happened: fn pointer coercion in stable
4232 // and usual function call in presense of unsized_locals.
4233 // Also, as we just want to check sizedness, instead of introducing
4234 // placeholder lifetimes with probing, we just replace higher lifetimes
4236 let output = self.replace_bound_vars_with_fresh_vars(
4238 infer::LateBoundRegionConversionTime::FnCall,
4239 &fn_sig.output()).0;
4240 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4243 // We always require that the type provided as the value for
4244 // a type parameter outlives the moment of instantiation.
4245 let substs = self.tables.borrow().node_substs(expr.hir_id);
4246 self.add_wf_bounds(substs, expr);
4250 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4251 for expr in outputs.iter().chain(inputs.iter()) {
4252 self.check_expr(expr);
4256 ExprKind::Break(destination, ref expr_opt) => {
4257 if let Ok(target_id) = destination.target_id {
4259 if let Some(ref e) = *expr_opt {
4260 // If this is a break with a value, we need to type-check
4261 // the expression. Get an expected type from the loop context.
4262 let opt_coerce_to = {
4263 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4264 enclosing_breakables.find_breakable(target_id)
4267 .map(|coerce| coerce.expected_ty())
4270 // If the loop context is not a `loop { }`, then break with
4271 // a value is illegal, and `opt_coerce_to` will be `None`.
4272 // Just set expectation to error in that case.
4273 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4275 // Recurse without `enclosing_breakables` borrowed.
4276 e_ty = self.check_expr_with_hint(e, coerce_to);
4277 cause = self.misc(e.span);
4279 // Otherwise, this is a break *without* a value. That's
4280 // always legal, and is equivalent to `break ()`.
4281 e_ty = tcx.mk_unit();
4282 cause = self.misc(expr.span);
4285 // Now that we have type-checked `expr_opt`, borrow
4286 // the `enclosing_loops` field and let's coerce the
4287 // type of `expr_opt` into what is expected.
4288 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4289 let ctxt = enclosing_breakables.find_breakable(target_id);
4290 if let Some(ref mut coerce) = ctxt.coerce {
4291 if let Some(ref e) = *expr_opt {
4292 coerce.coerce(self, &cause, e, e_ty);
4294 assert!(e_ty.is_unit());
4295 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4298 // If `ctxt.coerce` is `None`, we can just ignore
4299 // the type of the expresison. This is because
4300 // either this was a break *without* a value, in
4301 // which case it is always a legal type (`()`), or
4302 // else an error would have been flagged by the
4303 // `loops` pass for using break with an expression
4304 // where you are not supposed to.
4305 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4308 ctxt.may_break = true;
4310 // the type of a `break` is always `!`, since it diverges
4313 // Otherwise, we failed to find the enclosing loop;
4314 // this can only happen if the `break` was not
4315 // inside a loop at all, which is caught by the
4316 // loop-checking pass.
4317 if self.tcx.sess.err_count() == 0 {
4318 self.tcx.sess.delay_span_bug(expr.span,
4319 "break was outside loop, but no error was emitted");
4322 // We still need to assign a type to the inner expression to
4323 // prevent the ICE in #43162.
4324 if let Some(ref e) = *expr_opt {
4325 self.check_expr_with_hint(e, tcx.types.err);
4327 // ... except when we try to 'break rust;'.
4328 // ICE this expression in particular (see #43162).
4329 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4330 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4331 fatally_break_rust(self.tcx.sess);
4335 // There was an error; make type-check fail.
4340 ExprKind::Continue(destination) => {
4341 if destination.target_id.is_ok() {
4344 // There was an error; make type-check fail.
4348 ExprKind::Ret(ref expr_opt) => {
4349 if self.ret_coercion.is_none() {
4350 struct_span_err!(self.tcx.sess, expr.span, E0572,
4351 "return statement outside of function body").emit();
4352 } else if let Some(ref e) = *expr_opt {
4353 if self.ret_coercion_span.borrow().is_none() {
4354 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4356 self.check_return_expr(e);
4358 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4359 if self.ret_coercion_span.borrow().is_none() {
4360 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4362 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4363 if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
4364 coercion.coerce_forced_unit(
4369 fn_decl.output.span(),
4371 "expected `{}` because of this return type",
4379 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4384 ExprKind::Assign(ref lhs, ref rhs) => {
4385 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4387 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4390 ExpectIfCondition => {
4391 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4392 expected error elsehwere");
4395 // Only check this if not in an `if` condition, as the
4396 // mistyped comparison help is more appropriate.
4397 if !lhs.is_place_expr() {
4398 struct_span_err!(self.tcx.sess, expr.span, E0070,
4399 "invalid left-hand side expression")
4400 .span_label(expr.span, "left-hand of expression not valid")
4406 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4408 if lhs_ty.references_error() || rhs_ty.references_error() {
4414 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4415 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4416 expr.span, expected)
4418 ExprKind::While(ref cond, ref body, _) => {
4419 let ctxt = BreakableCtxt {
4420 // cannot use break with a value from a while loop
4422 may_break: false, // Will get updated if/when we find a `break`.
4425 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4426 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4427 let cond_diverging = self.diverges.get();
4428 self.check_block_no_value(&body);
4430 // We may never reach the body so it diverging means nothing.
4431 self.diverges.set(cond_diverging);
4435 // No way to know whether it's diverging because
4436 // of a `break` or an outer `break` or `return`.
4437 self.diverges.set(Diverges::Maybe);
4442 ExprKind::Loop(ref body, _, source) => {
4443 let coerce = match source {
4444 // you can only use break with a value from a normal `loop { }`
4445 hir::LoopSource::Loop => {
4446 let coerce_to = expected.coercion_target_type(self, body.span);
4447 Some(CoerceMany::new(coerce_to))
4450 hir::LoopSource::WhileLet |
4451 hir::LoopSource::ForLoop => {
4456 let ctxt = BreakableCtxt {
4458 may_break: false, // Will get updated if/when we find a `break`.
4461 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4462 self.check_block_no_value(&body);
4466 // No way to know whether it's diverging because
4467 // of a `break` or an outer `break` or `return`.
4468 self.diverges.set(Diverges::Maybe);
4471 // If we permit break with a value, then result type is
4472 // the LUB of the breaks (possibly ! if none); else, it
4473 // is nil. This makes sense because infinite loops
4474 // (which would have type !) are only possible iff we
4475 // permit break with a value [1].
4476 if ctxt.coerce.is_none() && !ctxt.may_break {
4478 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4480 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4482 ExprKind::Match(ref discrim, ref arms, match_src) => {
4483 self.check_match(expr, &discrim, arms, expected, match_src)
4485 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4486 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4488 ExprKind::Block(ref body, _) => {
4489 self.check_block_with_expected(&body, expected)
4491 ExprKind::Call(ref callee, ref args) => {
4492 self.check_call(expr, &callee, args, expected)
4494 ExprKind::MethodCall(ref segment, span, ref args) => {
4495 self.check_method_call(expr, segment, span, args, expected, needs)
4497 ExprKind::Cast(ref e, ref t) => {
4498 // Find the type of `e`. Supply hints based on the type we are casting to,
4500 let t_cast = self.to_ty_saving_user_provided_ty(t);
4501 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4502 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4503 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4505 // Eagerly check for some obvious errors.
4506 if t_expr.references_error() || t_cast.references_error() {
4509 // Defer other checks until we're done type checking.
4510 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4511 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4513 deferred_cast_checks.push(cast_check);
4516 Err(ErrorReported) => {
4522 ExprKind::Type(ref e, ref t) => {
4523 let ty = self.to_ty_saving_user_provided_ty(&t);
4524 self.check_expr_eq_type(&e, ty);
4527 ExprKind::Array(ref args) => {
4528 let uty = expected.to_option(self).and_then(|uty| {
4530 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4535 let element_ty = if !args.is_empty() {
4536 let coerce_to = uty.unwrap_or_else(
4537 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4538 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4539 assert_eq!(self.diverges.get(), Diverges::Maybe);
4541 let e_ty = self.check_expr_with_hint(e, coerce_to);
4542 let cause = self.misc(e.span);
4543 coerce.coerce(self, &cause, e, e_ty);
4545 coerce.complete(self)
4547 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4549 tcx.mk_array(element_ty, args.len() as u64)
4551 ExprKind::Repeat(ref element, ref count) => {
4552 let count_def_id = tcx.hir().local_def_id(count.id);
4553 let param_env = ty::ParamEnv::empty();
4554 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4555 let instance = ty::Instance::resolve(
4561 let global_id = GlobalId {
4565 let count = tcx.const_eval(param_env.and(global_id));
4567 let uty = match expected {
4568 ExpectHasType(uty) => {
4570 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4577 let (element_ty, t) = match uty {
4579 self.check_expr_coercable_to_type(&element, uty);
4583 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4584 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4589 if let Ok(count) = count {
4590 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4592 // For [foo, ..n] where n > 1, `foo` must have
4594 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4595 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4599 if element_ty.references_error() {
4601 } else if let Ok(count) = count {
4602 tcx.mk_ty(ty::Array(t, tcx.mk_lazy_const(ty::LazyConst::Evaluated(count))))
4607 ExprKind::Tup(ref elts) => {
4608 let flds = expected.only_has_type(self).and_then(|ty| {
4609 let ty = self.resolve_type_vars_with_obligations(ty);
4611 ty::Tuple(ref flds) => Some(&flds[..]),
4616 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4617 let t = match flds {
4618 Some(ref fs) if i < fs.len() => {
4620 self.check_expr_coercable_to_type(&e, ety);
4624 self.check_expr_with_expectation(&e, NoExpectation)
4629 let tuple = tcx.mk_tup(elt_ts_iter);
4630 if tuple.references_error() {
4633 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4637 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4638 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4640 ExprKind::Field(ref base, field) => {
4641 self.check_field(expr, needs, &base, field)
4643 ExprKind::Index(ref base, ref idx) => {
4644 let base_t = self.check_expr_with_needs(&base, needs);
4645 let idx_t = self.check_expr(&idx);
4647 if base_t.references_error() {
4649 } else if idx_t.references_error() {
4652 let base_t = self.structurally_resolved_type(base.span, base_t);
4653 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4654 Some((index_ty, element_ty)) => {
4655 // two-phase not needed because index_ty is never mutable
4656 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4661 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4662 "cannot index into a value of type `{}`",
4664 // Try to give some advice about indexing tuples.
4665 if let ty::Tuple(..) = base_t.sty {
4666 let mut needs_note = true;
4667 // If the index is an integer, we can show the actual
4668 // fixed expression:
4669 if let ExprKind::Lit(ref lit) = idx.node {
4670 if let ast::LitKind::Int(i,
4671 ast::LitIntType::Unsuffixed) = lit.node {
4672 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4673 if let Ok(snip) = snip {
4674 err.span_suggestion(
4676 "to access tuple elements, use",
4677 format!("{}.{}", snip, i),
4678 Applicability::MachineApplicable,
4685 err.help("to access tuple elements, use tuple indexing \
4686 syntax (e.g., `tuple.0`)");
4695 ExprKind::Yield(ref value) => {
4696 match self.yield_ty {
4698 self.check_expr_coercable_to_type(&value, ty);
4701 struct_span_err!(self.tcx.sess, expr.span, E0627,
4702 "yield statement outside of generator literal").emit();
4707 hir::ExprKind::Err => {
4713 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4714 // The newly resolved definition is written into `type_dependent_defs`.
4715 fn finish_resolving_struct_path(&self,
4718 node_id: ast::NodeId)
4722 QPath::Resolved(ref maybe_qself, ref path) => {
4723 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4724 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4727 QPath::TypeRelative(ref qself, ref segment) => {
4728 let ty = self.to_ty(qself);
4730 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4735 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4736 let (ty, def) = AstConv::associated_path_to_ty(self, hir_id, path_span,
4737 ty, def, segment, true);
4739 // Write back the new resolution.
4740 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4741 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4748 /// Resolves associated value path into a base type and associated constant or method
4749 /// definition. The newly resolved definition is written into `type_dependent_defs`.
4750 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4752 node_id: ast::NodeId,
4754 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4756 debug!("resolve_ty_and_def_ufcs: qpath={:?} node_id={:?} span={:?}", qpath, node_id, span);
4757 let (ty, qself, item_segment) = match *qpath {
4758 QPath::Resolved(ref opt_qself, ref path) => {
4760 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4761 &path.segments[..]);
4763 QPath::TypeRelative(ref qself, ref segment) => {
4764 (self.to_ty(qself), qself, segment)
4767 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4768 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4769 // Return directly on cache hit. This is useful to avoid doubly reporting
4770 // errors with default match binding modes. See #44614.
4771 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4773 let item_name = item_segment.ident;
4774 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4777 let def = match error {
4778 method::MethodError::PrivateMatch(def, _) => def,
4781 if item_name.name != keywords::Invalid.name() {
4782 self.report_method_error(span,
4785 SelfSource::QPath(qself),
4793 // Write back the new resolution.
4794 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4795 (def, Some(ty), slice::from_ref(&**item_segment))
4798 pub fn check_decl_initializer(&self,
4799 local: &'gcx hir::Local,
4800 init: &'gcx hir::Expr) -> Ty<'tcx>
4802 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4803 // for #42640 (default match binding modes).
4806 let ref_bindings = local.pat.contains_explicit_ref_binding();
4808 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4809 if let Some(m) = ref_bindings {
4810 // Somewhat subtle: if we have a `ref` binding in the pattern,
4811 // we want to avoid introducing coercions for the RHS. This is
4812 // both because it helps preserve sanity and, in the case of
4813 // ref mut, for soundness (issue #23116). In particular, in
4814 // the latter case, we need to be clear that the type of the
4815 // referent for the reference that results is *equal to* the
4816 // type of the place it is referencing, and not some
4817 // supertype thereof.
4818 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4819 self.demand_eqtype(init.span, local_ty, init_ty);
4822 self.check_expr_coercable_to_type(init, local_ty)
4826 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4827 let t = self.local_ty(local.span, local.id).decl_ty;
4828 self.write_ty(local.hir_id, t);
4830 if let Some(ref init) = local.init {
4831 let init_ty = self.check_decl_initializer(local, &init);
4832 if init_ty.references_error() {
4833 self.write_ty(local.hir_id, init_ty);
4837 self.check_pat_walk(
4840 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4843 let pat_ty = self.node_ty(local.pat.hir_id);
4844 if pat_ty.references_error() {
4845 self.write_ty(local.hir_id, pat_ty);
4849 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4850 // Don't do all the complex logic below for `DeclItem`.
4852 hir::StmtKind::Item(..) => return,
4853 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4856 self.warn_if_unreachable(stmt.id, stmt.span, "statement");
4858 // Hide the outer diverging and `has_errors` flags.
4859 let old_diverges = self.diverges.get();
4860 let old_has_errors = self.has_errors.get();
4861 self.diverges.set(Diverges::Maybe);
4862 self.has_errors.set(false);
4865 hir::StmtKind::Local(ref l) => {
4866 self.check_decl_local(&l);
4869 hir::StmtKind::Item(_) => {}
4870 hir::StmtKind::Expr(ref expr) => {
4871 // Check with expected type of `()`.
4872 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4874 hir::StmtKind::Semi(ref expr) => {
4875 self.check_expr(&expr);
4879 // Combine the diverging and `has_error` flags.
4880 self.diverges.set(self.diverges.get() | old_diverges);
4881 self.has_errors.set(self.has_errors.get() | old_has_errors);
4884 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4885 let unit = self.tcx.mk_unit();
4886 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4888 // if the block produces a `!` value, that can always be
4889 // (effectively) coerced to unit.
4891 self.demand_suptype(blk.span, unit, ty);
4895 fn check_block_with_expected(&self,
4896 blk: &'gcx hir::Block,
4897 expected: Expectation<'tcx>) -> Ty<'tcx> {
4899 let mut fcx_ps = self.ps.borrow_mut();
4900 let unsafety_state = fcx_ps.recurse(blk);
4901 replace(&mut *fcx_ps, unsafety_state)
4904 // In some cases, blocks have just one exit, but other blocks
4905 // can be targeted by multiple breaks. This can happen both
4906 // with labeled blocks as well as when we desugar
4907 // a `try { ... }` expression.
4911 // 'a: { if true { break 'a Err(()); } Ok(()) }
4913 // Here we would wind up with two coercions, one from
4914 // `Err(())` and the other from the tail expression
4915 // `Ok(())`. If the tail expression is omitted, that's a
4916 // "forced unit" -- unless the block diverges, in which
4917 // case we can ignore the tail expression (e.g., `'a: {
4918 // break 'a 22; }` would not force the type of the block
4920 let tail_expr = blk.expr.as_ref();
4921 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4922 let coerce = if blk.targeted_by_break {
4923 CoerceMany::new(coerce_to_ty)
4925 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4926 Some(e) => slice::from_ref(e),
4929 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4932 let prev_diverges = self.diverges.get();
4933 let ctxt = BreakableCtxt {
4934 coerce: Some(coerce),
4938 let blk_node_id = self.tcx.hir().hir_to_node_id(blk.hir_id);
4939 let (ctxt, ()) = self.with_breakable_ctxt(blk_node_id, ctxt, || {
4940 for s in &blk.stmts {
4944 // check the tail expression **without** holding the
4945 // `enclosing_breakables` lock below.
4946 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4948 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4949 let ctxt = enclosing_breakables.find_breakable(blk_node_id);
4950 let coerce = ctxt.coerce.as_mut().unwrap();
4951 if let Some(tail_expr_ty) = tail_expr_ty {
4952 let tail_expr = tail_expr.unwrap();
4953 let cause = self.cause(tail_expr.span,
4954 ObligationCauseCode::BlockTailExpression(blk_node_id));
4960 // Subtle: if there is no explicit tail expression,
4961 // that is typically equivalent to a tail expression
4962 // of `()` -- except if the block diverges. In that
4963 // case, there is no value supplied from the tail
4964 // expression (assuming there are no other breaks,
4965 // this implies that the type of the block will be
4968 // #41425 -- label the implicit `()` as being the
4969 // "found type" here, rather than the "expected type".
4970 if !self.diverges.get().always() {
4971 // #50009 -- Do not point at the entire fn block span, point at the return type
4972 // span, as it is the cause of the requirement, and
4973 // `consider_hint_about_removing_semicolon` will point at the last expression
4974 // if it were a relevant part of the error. This improves usability in editors
4975 // that highlight errors inline.
4976 let mut sp = blk.span;
4977 let mut fn_span = None;
4978 if let Some((decl, ident)) = self.get_parent_fn_decl(blk_node_id) {
4979 let ret_sp = decl.output.span();
4980 if let Some(block_sp) = self.parent_item_span(blk_node_id) {
4981 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4982 // output would otherwise be incorrect and even misleading. Make sure
4983 // the span we're aiming at correspond to a `fn` body.
4984 if block_sp == blk.span {
4986 fn_span = Some(ident.span);
4990 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4991 if let Some(expected_ty) = expected.only_has_type(self) {
4992 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4994 if let Some(fn_span) = fn_span {
4995 err.span_label(fn_span, "this function's body doesn't return");
5003 // If we can break from the block, then the block's exit is always reachable
5004 // (... as long as the entry is reachable) - regardless of the tail of the block.
5005 self.diverges.set(prev_diverges);
5008 let mut ty = ctxt.coerce.unwrap().complete(self);
5010 if self.has_errors.get() || ty.references_error() {
5011 ty = self.tcx.types.err
5014 self.write_ty(blk.hir_id, ty);
5016 *self.ps.borrow_mut() = prev;
5020 fn parent_item_span(&self, id: ast::NodeId) -> Option<Span> {
5021 let node = self.tcx.hir().get(self.tcx.hir().get_parent(id));
5023 Node::Item(&hir::Item {
5024 node: hir::ItemKind::Fn(_, _, _, body_id), ..
5026 Node::ImplItem(&hir::ImplItem {
5027 node: hir::ImplItemKind::Method(_, body_id), ..
5029 let body = self.tcx.hir().body(body_id);
5030 if let ExprKind::Block(block, _) = &body.value.node {
5031 return Some(block.span);
5039 /// Given a function block's `NodeId`, returns its `FnDecl` if it exists, or `None` otherwise.
5040 fn get_parent_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, ast::Ident)> {
5041 let parent = self.tcx.hir().get(self.tcx.hir().get_parent(blk_id));
5042 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
5045 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
5046 fn get_node_fn_decl(&self, node: Node) -> Option<(hir::FnDecl, ast::Ident, bool)> {
5048 Node::Item(&hir::Item {
5049 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
5050 }) => decl.clone().and_then(|decl| {
5051 // This is less than ideal, it will not suggest a return type span on any
5052 // method called `main`, regardless of whether it is actually the entry point,
5053 // but it will still present it as the reason for the expected type.
5054 Some((decl, ident, ident.name != Symbol::intern("main")))
5056 Node::TraitItem(&hir::TraitItem {
5057 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5060 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5061 Node::ImplItem(&hir::ImplItem {
5062 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5065 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5070 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
5071 /// suggestion can be made, `None` otherwise.
5072 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
5073 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5074 // `while` before reaching it, as block tail returns are not available in them.
5075 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5076 let parent = self.tcx.hir().get(blk_id);
5077 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5081 /// On implicit return expressions with mismatched types, provides the following suggestions:
5083 /// - Points out the method's return type as the reason for the expected type.
5084 /// - Possible missing semicolon.
5085 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5086 pub fn suggest_mismatched_types_on_tail(
5088 err: &mut DiagnosticBuilder<'tcx>,
5089 expression: &'gcx hir::Expr,
5093 blk_id: ast::NodeId,
5095 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5096 let mut pointing_at_return_type = false;
5097 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5098 pointing_at_return_type = self.suggest_missing_return_type(
5099 err, &fn_decl, expected, found, can_suggest);
5101 self.suggest_ref_or_into(err, expression, expected, found);
5102 pointing_at_return_type
5105 pub fn suggest_ref_or_into(
5107 err: &mut DiagnosticBuilder<'tcx>,
5112 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5113 err.span_suggestion(
5117 Applicability::MachineApplicable,
5119 } else if !self.check_for_cast(err, expr, found, expected) {
5120 let methods = self.get_conversion_methods(expr.span, expected, found);
5121 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5122 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5123 .filter_map(|(receiver, method)| {
5124 let method_call = format!(".{}()", method.ident);
5125 if receiver.ends_with(&method_call) {
5126 None // do not suggest code that is already there (#53348)
5128 let method_call_list = [".to_vec()", ".to_string()"];
5129 if receiver.ends_with(".clone()")
5130 && method_call_list.contains(&method_call.as_str()) {
5131 let max_len = receiver.rfind(".").unwrap();
5132 Some(format!("{}{}", &receiver[..max_len], method_call))
5135 Some(format!("{}{}", receiver, method_call))
5139 if suggestions.peek().is_some() {
5140 err.span_suggestions(
5142 "try using a conversion method",
5144 Applicability::MaybeIncorrect,
5151 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5155 /// bar_that_returns_u32()
5159 /// This routine checks if the return expression in a block would make sense on its own as a
5160 /// statement and the return type has been left as default or has been specified as `()`. If so,
5161 /// it suggests adding a semicolon.
5162 fn suggest_missing_semicolon(&self,
5163 err: &mut DiagnosticBuilder<'tcx>,
5164 expression: &'gcx hir::Expr,
5167 if expected.is_unit() {
5168 // `BlockTailExpression` only relevant if the tail expr would be
5169 // useful on its own.
5170 match expression.node {
5171 ExprKind::Call(..) |
5172 ExprKind::MethodCall(..) |
5174 ExprKind::While(..) |
5175 ExprKind::Loop(..) |
5176 ExprKind::Match(..) |
5177 ExprKind::Block(..) => {
5178 let sp = self.tcx.sess.source_map().next_point(cause_span);
5179 err.span_suggestion(
5181 "try adding a semicolon",
5183 Applicability::MachineApplicable);
5190 /// A possible error is to forget to add a return type that is needed:
5194 /// bar_that_returns_u32()
5198 /// This routine checks if the return type is left as default, the method is not part of an
5199 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5201 fn suggest_missing_return_type(
5203 err: &mut DiagnosticBuilder<'tcx>,
5204 fn_decl: &hir::FnDecl,
5209 // Only suggest changing the return type for methods that
5210 // haven't set a return type at all (and aren't `fn main()` or an impl).
5211 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5212 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5213 err.span_suggestion(
5215 "try adding a return type",
5216 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5217 Applicability::MachineApplicable);
5220 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5221 err.span_label(span, "possibly return type missing here?");
5224 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5225 // `fn main()` must return `()`, do not suggest changing return type
5226 err.span_label(span, "expected `()` because of default return type");
5229 // expectation was caused by something else, not the default return
5230 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5231 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5232 // Only point to return type if the expected type is the return type, as if they
5233 // are not, the expectation must have been caused by something else.
5234 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5236 let ty = AstConv::ast_ty_to_ty(self, ty);
5237 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5238 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5239 if ty.sty == expected.sty {
5240 err.span_label(sp, format!("expected `{}` because of return type",
5249 /// A common error is to add an extra semicolon:
5252 /// fn foo() -> usize {
5257 /// This routine checks if the final statement in a block is an
5258 /// expression with an explicit semicolon whose type is compatible
5259 /// with `expected_ty`. If so, it suggests removing the semicolon.
5260 fn consider_hint_about_removing_semicolon(
5262 blk: &'gcx hir::Block,
5263 expected_ty: Ty<'tcx>,
5264 err: &mut DiagnosticBuilder<'_>,
5266 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5267 err.span_suggestion(
5269 "consider removing this semicolon",
5271 Applicability::MachineApplicable,
5276 fn could_remove_semicolon(
5278 blk: &'gcx hir::Block,
5279 expected_ty: Ty<'tcx>,
5281 // Be helpful when the user wrote `{... expr;}` and
5282 // taking the `;` off is enough to fix the error.
5283 let last_stmt = match blk.stmts.last() {
5285 None => return None,
5287 let last_expr = match last_stmt.node {
5288 hir::StmtKind::Semi(ref e) => e,
5291 let last_expr_ty = self.node_ty(last_expr.hir_id);
5292 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5295 let original_span = original_sp(last_stmt.span, blk.span);
5296 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5299 // Instantiates the given path, which must refer to an item with the given
5300 // number of type parameters and type.
5301 pub fn instantiate_value_path(&self,
5302 segments: &[hir::PathSegment],
5303 self_ty: Option<Ty<'tcx>>,
5306 node_id: ast::NodeId)
5307 -> (Ty<'tcx>, Def) {
5309 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5318 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5320 let mut user_self_ty = None;
5321 let mut is_alias_variant_ctor = false;
5323 Def::VariantCtor(_, _) => {
5324 if let Some(self_ty) = self_ty {
5325 let adt_def = self_ty.ty_adt_def().unwrap();
5326 user_self_ty = Some(UserSelfTy {
5327 impl_def_id: adt_def.did,
5330 is_alias_variant_ctor = true;
5333 Def::Method(def_id) |
5334 Def::AssociatedConst(def_id) => {
5335 let container = tcx.associated_item(def_id).container;
5336 debug!("instantiate_value_path: def={:?} container={:?}", def, container);
5338 ty::TraitContainer(trait_did) => {
5339 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5341 ty::ImplContainer(impl_def_id) => {
5342 if segments.len() == 1 {
5343 // `<T>::assoc` will end up here, and so
5344 // can `T::assoc`. It this came from an
5345 // inherent impl, we need to record the
5346 // `T` for posterity (see `UserSelfTy` for
5348 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5349 user_self_ty = Some(UserSelfTy {
5360 // Now that we have categorized what space the parameters for each
5361 // segment belong to, let's sort out the parameters that the user
5362 // provided (if any) into their appropriate spaces. We'll also report
5363 // errors if type parameters are provided in an inappropriate place.
5365 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5366 let generics_has_err = AstConv::prohibit_generics(
5367 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5368 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5374 if generics_has_err {
5375 // Don't try to infer type parameters when prohibited generic arguments were given.
5376 user_self_ty = None;
5380 Def::Local(nid) | Def::Upvar(nid, ..) => {
5381 let ty = self.local_ty(span, nid).decl_ty;
5382 let ty = self.normalize_associated_types_in(span, &ty);
5383 self.write_ty(tcx.hir().node_to_hir_id(node_id), ty);
5389 // Now we have to compare the types that the user *actually*
5390 // provided against the types that were *expected*. If the user
5391 // did not provide any types, then we want to substitute inference
5392 // variables. If the user provided some types, we may still need
5393 // to add defaults. If the user provided *too many* types, that's
5396 let mut infer_args_for_err = FxHashSet::default();
5397 for &PathSeg(def_id, index) in &path_segs {
5398 let seg = &segments[index];
5399 let generics = tcx.generics_of(def_id);
5400 // Argument-position `impl Trait` is treated as a normal generic
5401 // parameter internally, but we don't allow users to specify the
5402 // parameter's value explicitly, so we have to do some error-
5404 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5409 false, // `is_method_call`
5411 if suppress_errors {
5412 infer_args_for_err.insert(index);
5413 self.set_tainted_by_errors(); // See issue #53251.
5417 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5418 tcx.generics_of(*def_id).has_self
5419 }).unwrap_or(false);
5421 let mut new_def = def;
5422 let (def_id, ty) = match def {
5423 Def::SelfCtor(impl_def_id) => {
5424 let ty = self.impl_self_ty(span, impl_def_id).ty;
5425 let adt_def = ty.ty_adt_def();
5428 Some(adt_def) if adt_def.has_ctor() => {
5429 let variant = adt_def.non_enum_variant();
5430 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5431 (variant.did, tcx.type_of(variant.did))
5434 let mut err = tcx.sess.struct_span_err(span,
5435 "the `Self` constructor can only be used with tuple or unit structs");
5436 if let Some(adt_def) = adt_def {
5437 match adt_def.adt_kind() {
5439 err.help("did you mean to use one of the enum's variants?");
5443 err.span_suggestion(
5445 "use curly brackets",
5446 String::from("Self { /* fields */ }"),
5447 Applicability::HasPlaceholders,
5454 (impl_def_id, tcx.types.err)
5459 let def_id = def.def_id();
5461 // The things we are substituting into the type should not contain
5462 // escaping late-bound regions, and nor should the base type scheme.
5463 let ty = tcx.type_of(def_id);
5468 let substs = AstConv::create_substs_for_generic_args(
5474 // Provide the generic args, and whether types should be inferred.
5476 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5479 // If we've encountered an `impl Trait`-related error, we're just
5480 // going to infer the arguments for better error messages.
5481 if !infer_args_for_err.contains(&index) {
5482 // Check whether the user has provided generic arguments.
5483 if let Some(ref data) = segments[index].args {
5484 return (Some(data), segments[index].infer_types);
5487 return (None, segments[index].infer_types);
5492 // Provide substitutions for parameters for which (valid) arguments have been provided.
5494 match (¶m.kind, arg) {
5495 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5496 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5498 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5499 self.to_ty(ty).into()
5501 _ => unreachable!(),
5504 // Provide substitutions for parameters for which arguments are inferred.
5505 |substs, param, infer_types| {
5507 GenericParamDefKind::Lifetime => {
5508 self.re_infer(span, Some(param)).unwrap().into()
5510 GenericParamDefKind::Type { has_default, .. } => {
5511 if !infer_types && has_default {
5512 // If we have a default, then we it doesn't matter that we're not
5513 // inferring the type arguments: we provide the default where any
5515 let default = tcx.type_of(param.def_id);
5518 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5521 // If no type arguments were provided, we have to infer them.
5522 // This case also occurs as a result of some malformed input, e.g.
5523 // a lifetime argument being given instead of a type parameter.
5524 // Using inference instead of `Error` gives better error messages.
5525 self.var_for_def(span, param)
5531 assert!(!substs.has_escaping_bound_vars());
5532 assert!(!ty.has_escaping_bound_vars());
5534 // First, store the "user substs" for later.
5535 let hir_id = tcx.hir().node_to_hir_id(node_id);
5536 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5538 // Add all the obligations that are required, substituting and
5539 // normalized appropriately.
5540 let bounds = self.instantiate_bounds(span, def_id, &substs);
5541 self.add_obligations_for_parameters(
5542 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5545 // Substitute the values for the type parameters into the type of
5546 // the referenced item.
5547 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5549 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5550 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5551 // is inherent, there is no `Self` parameter; instead, the impl needs
5552 // type parameters, which we can infer by unifying the provided `Self`
5553 // with the substituted impl type.
5554 // This also occurs for an enum variant on a type alias.
5555 let ty = tcx.type_of(impl_def_id);
5557 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5558 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5559 Ok(ok) => self.register_infer_ok_obligations(ok),
5562 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5569 self.check_rustc_args_require_const(def_id, node_id, span);
5571 debug!("instantiate_value_path: type of {:?} is {:?}",
5574 self.write_substs(hir_id, substs);
5576 (ty_substituted, new_def)
5579 fn check_rustc_args_require_const(&self,
5581 node_id: ast::NodeId,
5583 // We're only interested in functions tagged with
5584 // #[rustc_args_required_const], so ignore anything that's not.
5585 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5589 // If our calling expression is indeed the function itself, we're good!
5590 // If not, generate an error that this can only be called directly.
5591 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5592 if let ExprKind::Call(ref callee, ..) = expr.node {
5593 if callee.id == node_id {
5599 self.tcx.sess.span_err(span, "this function can only be invoked \
5600 directly, not through a function pointer");
5603 // Resolves `typ` by a single level if `typ` is a type variable.
5604 // If no resolution is possible, then an error is reported.
5605 // Numeric inference variables may be left unresolved.
5606 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5607 let ty = self.resolve_type_vars_with_obligations(ty);
5608 if !ty.is_ty_var() {
5611 if !self.is_tainted_by_errors() {
5612 self.need_type_info_err((**self).body_id, sp, ty)
5613 .note("type must be known at this point")
5616 self.demand_suptype(sp, self.tcx.types.err, ty);
5621 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5622 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5623 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5626 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5627 index = enclosing_breakables.stack.len();
5628 enclosing_breakables.by_id.insert(id, index);
5629 enclosing_breakables.stack.push(ctxt);
5633 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5634 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5635 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5636 enclosing_breakables.stack.pop().expect("missing breakable context")
5641 /// Instantiate a QueryResponse in a probe context, without a
5642 /// good ObligationCause.
5643 fn probe_instantiate_query_response(
5646 original_values: &OriginalQueryValues<'tcx>,
5647 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5648 ) -> InferResult<'tcx, Ty<'tcx>>
5650 self.instantiate_query_response_and_region_obligations(
5651 &traits::ObligationCause::misc(span, self.body_id),
5657 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5658 fn expr_in_place(&self, mut expr_id: ast::NodeId) -> bool {
5659 let mut contained_in_place = false;
5661 while let hir::Node::Expr(parent_expr) =
5662 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5664 match &parent_expr.node {
5665 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5666 if lhs.id == expr_id {
5667 contained_in_place = true;
5673 expr_id = parent_expr.id;
5680 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5681 generics: &ty::Generics,
5683 let own_counts = generics.own_counts();
5684 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5686 if own_counts.types == 0 {
5689 // Make a vector of booleans initially false, set to true when used.
5690 let mut types_used = vec![false; own_counts.types];
5692 for leaf_ty in ty.walk() {
5693 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5694 debug!("Found use of ty param num {}", idx);
5695 types_used[idx as usize - own_counts.lifetimes] = true;
5696 } else if let ty::Error = leaf_ty.sty {
5697 // If there is already another error, do not emit
5698 // an error for not using a type Parameter.
5699 assert!(tcx.sess.err_count() > 0);
5704 let types = generics.params.iter().filter(|param| match param.kind {
5705 ty::GenericParamDefKind::Type { .. } => true,
5708 for (&used, param) in types_used.iter().zip(types) {
5710 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5711 let span = tcx.hir().span_by_hir_id(id);
5712 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5713 .span_label(span, "unused type parameter")
5719 fn fatally_break_rust(sess: &Session) {
5720 let handler = sess.diagnostic();
5721 handler.span_bug_no_panic(
5723 "It looks like you're trying to break rust; would you like some ICE?",
5725 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5726 handler.note_without_error(
5727 "we would appreciate a joke overview: \
5728 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5730 handler.note_without_error(&format!("rustc {} running on {}",
5731 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5732 crate::session::config::host_triple(),
5736 fn potentially_plural_count(count: usize, word: &str) -> String {
5737 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })