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 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 middle::lang_items;
94 use 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 require_c_abi_if_variadic;
134 use session::{CompileIncomplete, Session};
135 use session::config::EntryFnType;
138 use util::captures::Captures;
139 use util::common::{ErrorReported, indenter};
140 use 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 /// Provide 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 {
391 pub def: ast::NodeId,
392 pub unsafety: hir::Unsafety,
393 pub unsafe_push_count: u32,
398 pub fn function(unsafety: hir::Unsafety, def: ast::NodeId) -> 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.id, self.unsafe_push_count.checked_add(1).unwrap()),
414 hir::PopUnsafeBlock(..) =>
415 (unsafety, blk.id, self.unsafe_push_count.checked_sub(1).unwrap()),
416 hir::UnsafeBlock(..) =>
417 (hir::Unsafety::Unsafe, blk.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> {
513 body_id: ast::NodeId,
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,
675 body_id: ast::NodeId,
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 def-id 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(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_node_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_node_id(def_id).unwrap();
844 let span = tcx.hir().span(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.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,
929 Some(DefId::local(tcx.hir().definitions().node_to_hir_id(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: ast::NodeId,
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, _: ast::NodeId) { }
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.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(fn_id));
1089 let outer_node_id = fcx.tcx.hir().as_local_node_id(outer_def_id).unwrap();
1090 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_node_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 let fn_hir_id = fcx.tcx.hir().node_to_hir_id(fn_id);
1114 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_hir_id, fn_sig);
1116 fcx.check_return_expr(&body.value);
1118 // We insert the deferred_generator_interiors entry after visiting the body.
1119 // This ensures that all nested generators appear before the entry of this generator.
1120 // resolve_generator_interiors relies on this property.
1121 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1122 let interior = fcx.next_ty_var(TypeVariableOrigin::MiscVariable(span));
1123 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1124 Some(GeneratorTypes {
1125 yield_ty: fcx.yield_ty.unwrap(),
1127 movability: can_be_generator.unwrap(),
1133 // Finalize the return check by taking the LUB of the return types
1134 // we saw and assigning it to the expected return type. This isn't
1135 // really expected to fail, since the coercions would have failed
1136 // earlier when trying to find a LUB.
1138 // However, the behavior around `!` is sort of complex. In the
1139 // event that the `actual_return_ty` comes back as `!`, that
1140 // indicates that the fn either does not return or "returns" only
1141 // values of type `!`. In this case, if there is an expected
1142 // return type that is *not* `!`, that should be ok. But if the
1143 // return type is being inferred, we want to "fallback" to `!`:
1145 // let x = move || panic!();
1147 // To allow for that, I am creating a type variable with diverging
1148 // fallback. This was deemed ever so slightly better than unifying
1149 // the return value with `!` because it allows for the caller to
1150 // make more assumptions about the return type (e.g., they could do
1152 // let y: Option<u32> = Some(x());
1154 // which would then cause this return type to become `u32`, not
1156 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1157 let mut actual_return_ty = coercion.complete(&fcx);
1158 if actual_return_ty.is_never() {
1159 actual_return_ty = fcx.next_diverging_ty_var(
1160 TypeVariableOrigin::DivergingFn(span));
1162 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1164 // Check that the main return type implements the termination trait.
1165 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1166 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1167 let main_id = fcx.tcx.hir().as_local_node_id(def_id).unwrap();
1168 if main_id == fn_id {
1169 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1170 let trait_ref = ty::TraitRef::new(term_id, substs);
1171 let return_ty_span = decl.output.span();
1172 let cause = traits::ObligationCause::new(
1173 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1175 inherited.register_predicate(
1176 traits::Obligation::new(
1177 cause, param_env, trait_ref.to_predicate()));
1182 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1183 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1184 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1185 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1186 // at this point we don't care if there are duplicate handlers or if the handler has
1187 // the wrong signature as this value we'll be used when writing metadata and that
1188 // only happens if compilation succeeded
1189 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1191 if declared_ret_ty.sty != ty::Never {
1192 fcx.tcx.sess.span_err(
1194 "return type should be `!`",
1198 let inputs = fn_sig.inputs();
1199 let span = fcx.tcx.hir().span(fn_id);
1200 if inputs.len() == 1 {
1201 let arg_is_panic_info = match inputs[0].sty {
1202 ty::Ref(region, ty, mutbl) => match ty.sty {
1203 ty::Adt(ref adt, _) => {
1204 adt.did == panic_info_did &&
1205 mutbl == hir::Mutability::MutImmutable &&
1206 *region != RegionKind::ReStatic
1213 if !arg_is_panic_info {
1214 fcx.tcx.sess.span_err(
1215 decl.inputs[0].span,
1216 "argument should be `&PanicInfo`",
1220 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1221 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1222 if !generics.params.is_empty() {
1223 fcx.tcx.sess.span_err(
1225 "should have no type parameters",
1231 let span = fcx.tcx.sess.source_map().def_span(span);
1232 fcx.tcx.sess.span_err(span, "function should have one argument");
1235 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1240 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1241 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1242 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1243 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1244 if declared_ret_ty.sty != ty::Never {
1245 fcx.tcx.sess.span_err(
1247 "return type should be `!`",
1251 let inputs = fn_sig.inputs();
1252 let span = fcx.tcx.hir().span(fn_id);
1253 if inputs.len() == 1 {
1254 let arg_is_alloc_layout = match inputs[0].sty {
1255 ty::Adt(ref adt, _) => {
1256 adt.did == alloc_layout_did
1261 if !arg_is_alloc_layout {
1262 fcx.tcx.sess.span_err(
1263 decl.inputs[0].span,
1264 "argument should be `Layout`",
1268 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1269 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1270 if !generics.params.is_empty() {
1271 fcx.tcx.sess.span_err(
1273 "`#[alloc_error_handler]` function should have no type \
1280 let span = fcx.tcx.sess.source_map().def_span(span);
1281 fcx.tcx.sess.span_err(span, "function should have one argument");
1284 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1292 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1295 let def_id = tcx.hir().local_def_id(id);
1296 let def = tcx.adt_def(def_id);
1297 def.destructor(tcx); // force the destructor to be evaluated
1298 check_representable(tcx, span, def_id);
1300 if def.repr.simd() {
1301 check_simd(tcx, span, def_id);
1304 check_transparent(tcx, span, def_id);
1305 check_packed(tcx, span, def_id);
1308 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1311 let def_id = tcx.hir().local_def_id(id);
1312 let def = tcx.adt_def(def_id);
1313 def.destructor(tcx); // force the destructor to be evaluated
1314 check_representable(tcx, span, def_id);
1316 check_packed(tcx, span, def_id);
1319 fn check_opaque<'a, 'tcx>(
1320 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1322 substs: &'tcx Substs<'tcx>,
1325 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1326 let mut err = struct_span_err!(
1327 tcx.sess, span, E0720,
1328 "opaque type expands to a recursive type",
1330 err.span_label(span, "expands to self-referential type");
1331 if let ty::Opaque(..) = partially_expanded_type.sty {
1332 err.note("type resolves to itself");
1334 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1340 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1342 "check_item_type(it.id={}, it.name={})",
1344 tcx.item_path_str(tcx.hir().local_def_id(it.id))
1346 let _indenter = indenter();
1348 // Consts can play a role in type-checking, so they are included here.
1349 hir::ItemKind::Static(..) => {
1350 let def_id = tcx.hir().local_def_id(it.id);
1351 tcx.typeck_tables_of(def_id);
1352 maybe_check_static_with_link_section(tcx, def_id, it.span);
1354 hir::ItemKind::Const(..) => {
1355 tcx.typeck_tables_of(tcx.hir().local_def_id(it.id));
1357 hir::ItemKind::Enum(ref enum_definition, _) => {
1358 check_enum(tcx, it.span, &enum_definition.variants, it.id);
1360 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1361 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1362 debug!("ItemKind::Impl {} with id {}", it.ident, it.id);
1363 let impl_def_id = tcx.hir().local_def_id(it.id);
1364 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1365 check_impl_items_against_trait(
1372 let trait_def_id = impl_trait_ref.def_id;
1373 check_on_unimplemented(tcx, trait_def_id, it);
1376 hir::ItemKind::Trait(..) => {
1377 let def_id = tcx.hir().local_def_id(it.id);
1378 check_on_unimplemented(tcx, def_id, it);
1380 hir::ItemKind::Struct(..) => {
1381 check_struct(tcx, it.id, it.span);
1383 hir::ItemKind::Union(..) => {
1384 check_union(tcx, it.id, it.span);
1386 hir::ItemKind::Existential(..) => {
1387 let def_id = tcx.hir().local_def_id(it.id);
1388 let pty_ty = tcx.type_of(def_id);
1389 let generics = tcx.generics_of(def_id);
1391 check_bounds_are_used(tcx, &generics, pty_ty);
1392 let substs = Substs::identity_for_item(tcx, def_id);
1393 check_opaque(tcx, def_id, substs, it.span);
1395 hir::ItemKind::Ty(..) => {
1396 let def_id = tcx.hir().local_def_id(it.id);
1397 let pty_ty = tcx.type_of(def_id);
1398 let generics = tcx.generics_of(def_id);
1399 check_bounds_are_used(tcx, &generics, pty_ty);
1401 hir::ItemKind::ForeignMod(ref m) => {
1402 check_abi(tcx, it.span, m.abi);
1404 if m.abi == Abi::RustIntrinsic {
1405 for item in &m.items {
1406 intrinsic::check_intrinsic_type(tcx, item);
1408 } else if m.abi == Abi::PlatformIntrinsic {
1409 for item in &m.items {
1410 intrinsic::check_platform_intrinsic_type(tcx, item);
1413 for item in &m.items {
1414 let generics = tcx.generics_of(tcx.hir().local_def_id(item.id));
1415 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1416 let mut err = struct_span_err!(
1420 "foreign items may not have type parameters"
1422 err.span_label(item.span, "can't have type parameters");
1423 // FIXME: once we start storing spans for type arguments, turn this into a
1426 "use specialization instead of type parameters by replacing them \
1427 with concrete types like `u32`",
1432 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1433 require_c_abi_if_variadic(tcx, fn_decl, m.abi, item.span);
1438 _ => { /* nothing to do */ }
1442 fn maybe_check_static_with_link_section(tcx: TyCtxt, id: DefId, span: Span) {
1443 // Only restricted on wasm32 target for now
1444 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1448 // If `#[link_section]` is missing, then nothing to verify
1449 let attrs = tcx.codegen_fn_attrs(id);
1450 if attrs.link_section.is_none() {
1454 // For the wasm32 target statics with #[link_section] are placed into custom
1455 // sections of the final output file, but this isn't link custom sections of
1456 // other executable formats. Namely we can only embed a list of bytes,
1457 // nothing with pointers to anything else or relocations. If any relocation
1458 // show up, reject them here.
1459 let instance = ty::Instance::mono(tcx, id);
1460 let cid = GlobalId {
1464 let param_env = ty::ParamEnv::reveal_all();
1465 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1466 let alloc = if let ConstValue::ByRef(_, allocation, _) = static_.val {
1469 bug!("Matching on non-ByRef static")
1471 if alloc.relocations.len() != 0 {
1472 let msg = "statics with a custom `#[link_section]` must be a \
1473 simple list of bytes on the wasm target with no \
1474 extra levels of indirection such as references";
1475 tcx.sess.span_err(span, msg);
1480 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1481 trait_def_id: DefId,
1483 let item_def_id = tcx.hir().local_def_id(item.id);
1484 // an error would be reported if this fails.
1485 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1488 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1489 impl_item: &hir::ImplItem,
1492 let mut err = struct_span_err!(
1493 tcx.sess, impl_item.span, E0520,
1494 "`{}` specializes an item from a parent `impl`, but \
1495 that item is not marked `default`",
1497 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1500 match tcx.span_of_impl(parent_impl) {
1502 err.span_label(span, "parent `impl` is here");
1503 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1507 err.note(&format!("parent implementation is in crate `{}`", cname));
1514 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1515 trait_def: &ty::TraitDef,
1516 trait_item: &ty::AssociatedItem,
1518 impl_item: &hir::ImplItem)
1520 let ancestors = trait_def.ancestors(tcx, impl_id);
1522 let kind = match impl_item.node {
1523 hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
1524 hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
1525 hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
1526 hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
1529 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1530 .map(|node_item| node_item.map(|parent| parent.defaultness));
1532 if let Some(parent) = parent {
1533 if tcx.impl_item_is_final(&parent) {
1534 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1540 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1543 impl_trait_ref: ty::TraitRef<'tcx>,
1544 impl_item_refs: &[hir::ImplItemRef]) {
1545 let impl_span = tcx.sess.source_map().def_span(impl_span);
1547 // If the trait reference itself is erroneous (so the compilation is going
1548 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1549 // isn't populated for such impls.
1550 if impl_trait_ref.references_error() { return; }
1552 // Locate trait definition and items
1553 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1554 let mut overridden_associated_type = None;
1556 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1558 // Check existing impl methods to see if they are both present in trait
1559 // and compatible with trait signature
1560 for impl_item in impl_items() {
1561 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.id));
1562 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1563 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1564 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1566 // Not compatible, but needed for the error message
1567 tcx.associated_items(impl_trait_ref.def_id)
1568 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1571 // Check that impl definition matches trait definition
1572 if let Some(ty_trait_item) = ty_trait_item {
1573 match impl_item.node {
1574 hir::ImplItemKind::Const(..) => {
1575 // Find associated const definition.
1576 if ty_trait_item.kind == ty::AssociatedKind::Const {
1577 compare_const_impl(tcx,
1583 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1584 "item `{}` is an associated const, \
1585 which doesn't match its trait `{}`",
1588 err.span_label(impl_item.span, "does not match trait");
1589 // We can only get the spans from local trait definition
1590 // Same for E0324 and E0325
1591 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1592 err.span_label(trait_span, "item in trait");
1597 hir::ImplItemKind::Method(..) => {
1598 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1599 if ty_trait_item.kind == ty::AssociatedKind::Method {
1600 compare_impl_method(tcx,
1607 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1608 "item `{}` is an associated method, \
1609 which doesn't match its trait `{}`",
1612 err.span_label(impl_item.span, "does not match trait");
1613 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1614 err.span_label(trait_span, "item in trait");
1619 hir::ImplItemKind::Existential(..) |
1620 hir::ImplItemKind::Type(_) => {
1621 if ty_trait_item.kind == ty::AssociatedKind::Type {
1622 if ty_trait_item.defaultness.has_value() {
1623 overridden_associated_type = Some(impl_item);
1626 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1627 "item `{}` is an associated type, \
1628 which doesn't match its trait `{}`",
1631 err.span_label(impl_item.span, "does not match trait");
1632 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1633 err.span_label(trait_span, "item in trait");
1640 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1644 // Check for missing items from trait
1645 let mut missing_items = Vec::new();
1646 let mut invalidated_items = Vec::new();
1647 let associated_type_overridden = overridden_associated_type.is_some();
1648 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1649 let is_implemented = trait_def.ancestors(tcx, impl_id)
1650 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1652 .map(|node_item| !node_item.node.is_from_trait())
1655 if !is_implemented && !tcx.impl_is_default(impl_id) {
1656 if !trait_item.defaultness.has_value() {
1657 missing_items.push(trait_item);
1658 } else if associated_type_overridden {
1659 invalidated_items.push(trait_item.ident);
1664 if !missing_items.is_empty() {
1665 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1666 "not all trait items implemented, missing: `{}`",
1667 missing_items.iter()
1668 .map(|trait_item| trait_item.ident.to_string())
1669 .collect::<Vec<_>>().join("`, `"));
1670 err.span_label(impl_span, format!("missing `{}` in implementation",
1671 missing_items.iter()
1672 .map(|trait_item| trait_item.ident.to_string())
1673 .collect::<Vec<_>>().join("`, `")));
1674 for trait_item in missing_items {
1675 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1676 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1678 err.note_trait_signature(trait_item.ident.to_string(),
1679 trait_item.signature(&tcx));
1685 if !invalidated_items.is_empty() {
1686 let invalidator = overridden_associated_type.unwrap();
1687 span_err!(tcx.sess, invalidator.span, E0399,
1688 "the following trait items need to be reimplemented \
1689 as `{}` was overridden: `{}`",
1691 invalidated_items.iter()
1692 .map(|name| name.to_string())
1693 .collect::<Vec<_>>().join("`, `"))
1697 /// Checks whether a type can be represented in memory. In particular, it
1698 /// identifies types that contain themselves without indirection through a
1699 /// pointer, which would mean their size is unbounded.
1700 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1704 let rty = tcx.type_of(item_def_id);
1706 // Check that it is possible to represent this type. This call identifies
1707 // (1) types that contain themselves and (2) types that contain a different
1708 // recursive type. It is only necessary to throw an error on those that
1709 // contain themselves. For case 2, there must be an inner type that will be
1710 // caught by case 1.
1711 match rty.is_representable(tcx, sp) {
1712 Representability::SelfRecursive(spans) => {
1713 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1715 err.span_label(span, "recursive without indirection");
1720 Representability::Representable | Representability::ContainsRecursive => (),
1725 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1726 let t = tcx.type_of(def_id);
1727 if let ty::Adt(def, substs) = t.sty {
1728 if def.is_struct() {
1729 let fields = &def.non_enum_variant().fields;
1730 if fields.is_empty() {
1731 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1734 let e = fields[0].ty(tcx, substs);
1735 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1736 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1737 .span_label(sp, "SIMD elements must have the same type")
1742 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1743 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1745 span_err!(tcx.sess, sp, E0077,
1746 "SIMD vector element type should be machine type");
1754 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1755 let repr = tcx.adt_def(def_id).repr;
1757 for attr in tcx.get_attrs(def_id).iter() {
1758 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1759 if let attr::ReprPacked(pack) = r {
1760 if pack != repr.pack {
1761 struct_span_err!(tcx.sess, sp, E0634,
1762 "type has conflicting packed representation hints").emit();
1768 struct_span_err!(tcx.sess, sp, E0587,
1769 "type has conflicting packed and align representation hints").emit();
1771 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1772 struct_span_err!(tcx.sess, sp, E0588,
1773 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1778 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1780 stack: &mut Vec<DefId>) -> bool {
1781 let t = tcx.type_of(def_id);
1782 if stack.contains(&def_id) {
1783 debug!("check_packed_inner: {:?} is recursive", t);
1786 if let ty::Adt(def, substs) = t.sty {
1787 if def.is_struct() || def.is_union() {
1788 if tcx.adt_def(def.did).repr.align > 0 {
1791 // push struct def_id before checking fields
1793 for field in &def.non_enum_variant().fields {
1794 let f = field.ty(tcx, substs);
1795 if let ty::Adt(def, _) = f.sty {
1796 if check_packed_inner(tcx, def.did, stack) {
1801 // only need to pop if not early out
1808 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1809 let adt = tcx.adt_def(def_id);
1810 if !adt.repr.transparent() {
1814 // For each field, figure out if it's known to be a ZST and align(1)
1815 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1816 let ty = field.ty(tcx, Substs::identity_for_item(tcx, field.did));
1817 let param_env = tcx.param_env(field.did);
1818 let layout = tcx.layout_of(param_env.and(ty));
1819 // We are currently checking the type this field came from, so it must be local
1820 let span = tcx.hir().span_if_local(field.did).unwrap();
1821 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1822 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1826 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1827 let non_zst_count = non_zst_fields.clone().count();
1828 if non_zst_count != 1 {
1829 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1830 struct_span_err!(tcx.sess, sp, E0690,
1831 "transparent struct needs exactly one non-zero-sized field, but has {}",
1833 .span_note(field_spans, "non-zero-sized field")
1836 for (span, zst, align1) in field_infos {
1838 span_err!(tcx.sess, span, E0691,
1839 "zero-sized field in transparent struct has alignment larger than 1");
1844 #[allow(trivial_numeric_casts)]
1845 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1847 vs: &'tcx [hir::Variant],
1849 let def_id = tcx.hir().local_def_id(id);
1850 let def = tcx.adt_def(def_id);
1851 def.destructor(tcx); // force the destructor to be evaluated
1854 let attributes = tcx.get_attrs(def_id);
1855 if let Some(attr) = attr::find_by_name(&attributes, "repr") {
1857 tcx.sess, attr.span, E0084,
1858 "unsupported representation for zero-variant enum")
1859 .span_label(sp, "zero-variant enum")
1864 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1865 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1866 if !tcx.features().repr128 {
1867 emit_feature_err(&tcx.sess.parse_sess,
1870 GateIssue::Language,
1871 "repr with 128-bit type is unstable");
1876 if let Some(ref e) = v.node.disr_expr {
1877 tcx.typeck_tables_of(tcx.hir().local_def_id(e.id));
1881 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1882 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1883 // Check for duplicate discriminant values
1884 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1885 let variant_did = def.variants[VariantIdx::new(i)].did;
1886 let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap();
1887 let variant_i = tcx.hir().expect_variant(variant_i_node_id);
1888 let i_span = match variant_i.node.disr_expr {
1889 Some(ref expr) => tcx.hir().span(expr.id),
1890 None => tcx.hir().span(variant_i_node_id)
1892 let span = match v.node.disr_expr {
1893 Some(ref expr) => tcx.hir().span(expr.id),
1896 struct_span_err!(tcx.sess, span, E0081,
1897 "discriminant value `{}` already exists", disr_vals[i])
1898 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1899 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1902 disr_vals.push(discr);
1905 check_representable(tcx, sp, def_id);
1908 fn report_unexpected_variant_def<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1912 span_err!(tcx.sess, span, E0533,
1913 "expected unit struct/variant or constant, found {} `{}`",
1915 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1918 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1919 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1921 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1922 -> Lrc<ty::GenericPredicates<'tcx>>
1925 let node_id = tcx.hir().as_local_node_id(def_id).unwrap();
1926 let item_id = tcx.hir().ty_param_owner(node_id);
1927 let item_def_id = tcx.hir().local_def_id(item_id);
1928 let generics = tcx.generics_of(item_def_id);
1929 let index = generics.param_def_id_to_index[&def_id];
1930 Lrc::new(ty::GenericPredicates {
1932 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1934 ty::Predicate::Trait(ref data)
1935 if data.skip_binder().self_ty().is_param(index) => {
1936 // HACK(eddyb) should get the original `Span`.
1937 let span = tcx.def_span(def_id);
1938 Some((predicate, span))
1946 fn re_infer(&self, span: Span, def: Option<&ty::GenericParamDef>)
1947 -> Option<ty::Region<'tcx>> {
1949 Some(def) => infer::EarlyBoundRegion(span, def.name),
1950 None => infer::MiscVariable(span)
1952 Some(self.next_region_var(v))
1955 fn ty_infer(&self, span: Span) -> Ty<'tcx> {
1956 self.next_ty_var(TypeVariableOrigin::TypeInference(span))
1959 fn ty_infer_for_def(&self,
1960 ty_param_def: &ty::GenericParamDef,
1961 span: Span) -> Ty<'tcx> {
1962 if let UnpackedKind::Type(ty) = self.var_for_def(span, ty_param_def).unpack() {
1968 fn projected_ty_from_poly_trait_ref(&self,
1971 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1974 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1976 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1980 self.tcx().mk_projection(item_def_id, trait_ref.substs)
1983 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
1984 if ty.has_escaping_bound_vars() {
1985 ty // FIXME: normalization and escaping regions
1987 self.normalize_associated_types_in(span, &ty)
1991 fn set_tainted_by_errors(&self) {
1992 self.infcx.set_tainted_by_errors()
1995 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
1996 self.write_ty(hir_id, ty)
2000 /// Controls whether the arguments are tupled. This is used for the call
2003 /// Tupling means that all call-side arguments are packed into a tuple and
2004 /// passed as a single parameter. For example, if tupling is enabled, this
2007 /// fn f(x: (isize, isize))
2009 /// Can be called as:
2016 #[derive(Clone, Eq, PartialEq)]
2017 enum TupleArgumentsFlag {
2022 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2023 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2024 param_env: ty::ParamEnv<'tcx>,
2025 body_id: ast::NodeId)
2026 -> FnCtxt<'a, 'gcx, 'tcx> {
2030 err_count_on_creation: inh.tcx.sess.err_count(),
2032 ret_coercion_span: RefCell::new(None),
2034 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2035 ast::CRATE_NODE_ID)),
2036 diverges: Cell::new(Diverges::Maybe),
2037 has_errors: Cell::new(false),
2038 enclosing_breakables: RefCell::new(EnclosingBreakables {
2040 by_id: Default::default(),
2046 pub fn sess(&self) -> &Session {
2050 pub fn err_count_since_creation(&self) -> usize {
2051 self.tcx.sess.err_count() - self.err_count_on_creation
2054 /// Produce warning on the given node, if the current point in the
2055 /// function is unreachable, and there hasn't been another warning.
2056 fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
2057 if self.diverges.get() == Diverges::Always {
2058 self.diverges.set(Diverges::WarnedAlways);
2060 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2062 self.tcx().lint_node(
2063 lint::builtin::UNREACHABLE_CODE,
2065 &format!("unreachable {}", kind));
2071 code: ObligationCauseCode<'tcx>)
2072 -> ObligationCause<'tcx> {
2073 ObligationCause::new(span, self.body_id, code)
2076 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2077 self.cause(span, ObligationCauseCode::MiscObligation)
2080 /// Resolves type variables in `ty` if possible. Unlike the infcx
2081 /// version (resolve_type_vars_if_possible), this version will
2082 /// also select obligations if it seems useful, in an effort
2083 /// to get more type information.
2084 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2085 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2087 // No Infer()? Nothing needs doing.
2088 if !ty.has_infer_types() {
2089 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2093 // If `ty` is a type variable, see whether we already know what it is.
2094 ty = self.resolve_type_vars_if_possible(&ty);
2095 if !ty.has_infer_types() {
2096 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2100 // If not, try resolving pending obligations as much as
2101 // possible. This can help substantially when there are
2102 // indirect dependencies that don't seem worth tracking
2104 self.select_obligations_where_possible(false);
2105 ty = self.resolve_type_vars_if_possible(&ty);
2107 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2111 fn record_deferred_call_resolution(&self,
2112 closure_def_id: DefId,
2113 r: DeferredCallResolution<'gcx, 'tcx>) {
2114 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2115 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2118 fn remove_deferred_call_resolutions(&self,
2119 closure_def_id: DefId)
2120 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2122 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2123 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2126 pub fn tag(&self) -> String {
2127 let self_ptr: *const FnCtxt = self;
2128 format!("{:?}", self_ptr)
2131 pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> LocalTy<'tcx> {
2132 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2133 span_bug!(span, "no type for local variable {}",
2134 self.tcx.hir().node_to_string(nid))
2139 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2140 debug!("write_ty({:?}, {:?}) in fcx {}",
2141 id, self.resolve_type_vars_if_possible(&ty), self.tag());
2142 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2144 if ty.references_error() {
2145 self.has_errors.set(true);
2146 self.set_tainted_by_errors();
2150 pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
2151 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
2152 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2155 pub fn write_method_call(&self,
2157 method: MethodCallee<'tcx>) {
2158 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2161 .type_dependent_defs_mut()
2162 .insert(hir_id, Def::Method(method.def_id));
2164 self.write_substs(hir_id, method.substs);
2166 // When the method is confirmed, the `method.substs` includes
2167 // parameters from not just the method, but also the impl of
2168 // the method -- in particular, the `Self` type will be fully
2169 // resolved. However, those are not something that the "user
2170 // specified" -- i.e., those types come from the inferred type
2171 // of the receiver, not something the user wrote. So when we
2172 // create the user-substs, we want to replace those earlier
2173 // types with just the types that the user actually wrote --
2174 // that is, those that appear on the *method itself*.
2176 // As an example, if the user wrote something like
2177 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2178 // type of `foo` (possibly adjusted), but we don't want to
2179 // include that. We want just the `[_, u32]` part.
2180 if !method.substs.is_noop() {
2181 let method_generics = self.tcx.generics_of(method.def_id);
2182 if !method_generics.params.is_empty() {
2183 let user_type_annotation = self.infcx.probe(|_| {
2184 let user_substs = UserSubsts {
2185 substs: Substs::for_item(self.tcx, method.def_id, |param, _| {
2186 let i = param.index as usize;
2187 if i < method_generics.parent_count {
2188 self.infcx.var_for_def(DUMMY_SP, param)
2193 user_self_ty: None, // not relevant here
2196 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2202 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2203 self.write_user_type_annotation(hir_id, user_type_annotation);
2208 pub fn write_substs(&self, node_id: hir::HirId, substs: &'tcx Substs<'tcx>) {
2209 if !substs.is_noop() {
2210 debug!("write_substs({:?}, {:?}) in fcx {}",
2215 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2219 /// Given the substs that we just converted from the HIR, try to
2220 /// canonicalize them and store them as user-given substitutions
2221 /// (i.e., substitutions that must be respected by the NLL check).
2223 /// This should be invoked **before any unifications have
2224 /// occurred**, so that annotations like `Vec<_>` are preserved
2226 pub fn write_user_type_annotation_from_substs(
2230 substs: &'tcx Substs<'tcx>,
2231 user_self_ty: Option<UserSelfTy<'tcx>>,
2234 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2235 user_self_ty={:?} in fcx {}",
2236 hir_id, def_id, substs, user_self_ty, self.tag(),
2239 if !substs.is_noop() {
2240 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2241 &UserType::TypeOf(def_id, UserSubsts {
2246 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2247 self.write_user_type_annotation(hir_id, canonicalized);
2251 pub fn write_user_type_annotation(
2254 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2257 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2258 hir_id, canonical_user_type_annotation, self.tag(),
2261 if !canonical_user_type_annotation.is_identity() {
2262 self.tables.borrow_mut().user_provided_types_mut().insert(
2263 hir_id, canonical_user_type_annotation
2266 debug!("write_user_type_annotation: skipping identity substs");
2270 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2271 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2277 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2278 Entry::Vacant(entry) => { entry.insert(adj); },
2279 Entry::Occupied(mut entry) => {
2280 debug!(" - composing on top of {:?}", entry.get());
2281 match (&entry.get()[..], &adj[..]) {
2282 // Applying any adjustment on top of a NeverToAny
2283 // is a valid NeverToAny adjustment, because it can't
2285 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2287 Adjustment { kind: Adjust::Deref(_), .. },
2288 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2290 Adjustment { kind: Adjust::Deref(_), .. },
2291 .. // Any following adjustments are allowed.
2293 // A reborrow has no effect before a dereference.
2295 // FIXME: currently we never try to compose autoderefs
2296 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2298 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2299 expr, entry.get(), adj)
2301 *entry.get_mut() = adj;
2306 /// Basically whenever we are converting from a type scheme into
2307 /// the fn body space, we always want to normalize associated
2308 /// types as well. This function combines the two.
2309 fn instantiate_type_scheme<T>(&self,
2311 substs: &Substs<'tcx>,
2314 where T : TypeFoldable<'tcx>
2316 let value = value.subst(self.tcx, substs);
2317 let result = self.normalize_associated_types_in(span, &value);
2318 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2325 /// As `instantiate_type_scheme`, but for the bounds found in a
2326 /// generic type scheme.
2327 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: &Substs<'tcx>)
2328 -> ty::InstantiatedPredicates<'tcx> {
2329 let bounds = self.tcx.predicates_of(def_id);
2330 let result = bounds.instantiate(self.tcx, substs);
2331 let result = self.normalize_associated_types_in(span, &result);
2332 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2339 /// Replace the opaque types from the given value with type variables,
2340 /// and records the `OpaqueTypeMap` for later use during writeback. See
2341 /// `InferCtxt::instantiate_opaque_types` for more details.
2342 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2344 parent_id: ast::NodeId,
2347 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2348 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2352 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2353 self.instantiate_opaque_types(
2361 let mut opaque_types = self.opaque_types.borrow_mut();
2362 for (ty, decl) in opaque_type_map {
2363 let old_value = opaque_types.insert(ty, decl);
2364 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2370 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2371 where T : TypeFoldable<'tcx>
2373 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2376 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2378 where T : TypeFoldable<'tcx>
2380 self.inh.partially_normalize_associated_types_in(span,
2386 pub fn require_type_meets(&self,
2389 code: traits::ObligationCauseCode<'tcx>,
2392 self.register_bound(
2395 traits::ObligationCause::new(span, self.body_id, code));
2398 pub fn require_type_is_sized(&self,
2401 code: traits::ObligationCauseCode<'tcx>)
2403 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2404 self.require_type_meets(ty, span, code, lang_item);
2407 pub fn require_type_is_sized_deferred(&self,
2410 code: traits::ObligationCauseCode<'tcx>)
2412 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2415 pub fn register_bound(&self,
2418 cause: traits::ObligationCause<'tcx>)
2420 self.fulfillment_cx.borrow_mut()
2421 .register_bound(self, self.param_env, ty, def_id, cause);
2424 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2425 let t = AstConv::ast_ty_to_ty(self, ast_t);
2426 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2430 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2431 let ty = self.to_ty(ast_ty);
2432 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2434 // If the type given by the user has free regions, save it for
2435 // later, since NLL would like to enforce those. Also pass in
2436 // types that involve projections, since those can resolve to
2437 // `'static` bounds (modulo #54940, which hopefully will be
2438 // fixed by the time you see this comment, dear reader,
2439 // although I have my doubts). Also pass in types with inference
2440 // types, because they may be repeated. Other sorts of things
2441 // are already sufficiently enforced with erased regions. =)
2442 if ty.has_free_regions() || ty.has_projections() || ty.has_infer_types() {
2443 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2444 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2445 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2451 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2452 match self.tables.borrow().node_types().get(id) {
2454 None if self.is_tainted_by_errors() => self.tcx.types.err,
2456 let node_id = self.tcx.hir().hir_to_node_id(id);
2457 bug!("no type for node {}: {} in fcx {}",
2458 node_id, self.tcx.hir().node_to_string(node_id),
2464 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2465 /// outlive the region `r`.
2466 pub fn register_wf_obligation(&self,
2469 code: traits::ObligationCauseCode<'tcx>)
2471 // WF obligations never themselves fail, so no real need to give a detailed cause:
2472 let cause = traits::ObligationCause::new(span, self.body_id, code);
2473 self.register_predicate(traits::Obligation::new(cause,
2475 ty::Predicate::WellFormed(ty)));
2478 /// Registers obligations that all types appearing in `substs` are well-formed.
2479 pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &hir::Expr) {
2480 for ty in substs.types() {
2481 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2485 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2486 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2487 /// trait/region obligations.
2489 /// For example, if there is a function:
2492 /// fn foo<'a,T:'a>(...)
2495 /// and a reference:
2501 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2502 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2503 pub fn add_obligations_for_parameters(&self,
2504 cause: traits::ObligationCause<'tcx>,
2505 predicates: &ty::InstantiatedPredicates<'tcx>)
2507 assert!(!predicates.has_escaping_bound_vars());
2509 debug!("add_obligations_for_parameters(predicates={:?})",
2512 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2513 self.register_predicate(obligation);
2517 // FIXME(arielb1): use this instead of field.ty everywhere
2518 // Only for fields! Returns <none> for methods>
2519 // Indifferent to privacy flags
2520 pub fn field_ty(&self,
2522 field: &'tcx ty::FieldDef,
2523 substs: &Substs<'tcx>)
2526 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2529 fn check_casts(&self) {
2530 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2531 for cast in deferred_cast_checks.drain(..) {
2536 fn resolve_generator_interiors(&self, def_id: DefId) {
2537 let mut generators = self.deferred_generator_interiors.borrow_mut();
2538 for (body_id, interior) in generators.drain(..) {
2539 self.select_obligations_where_possible(false);
2540 generator_interior::resolve_interior(self, def_id, body_id, interior);
2544 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2545 // Non-numerics get replaced with ! or () (depending on whether
2546 // feature(never_type) is enabled, unconstrained ints with i32,
2547 // unconstrained floats with f64.
2548 // Fallback becomes very dubious if we have encountered type-checking errors.
2549 // In that case, fallback to Error.
2550 // The return value indicates whether fallback has occurred.
2551 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2552 use rustc::ty::error::UnconstrainedNumeric::Neither;
2553 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2555 assert!(ty.is_ty_infer());
2556 let fallback = match self.type_is_unconstrained_numeric(ty) {
2557 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2558 UnconstrainedInt => self.tcx.types.i32,
2559 UnconstrainedFloat => self.tcx.types.f64,
2560 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2561 Neither => return false,
2563 debug!("default_type_parameters: defaulting `{:?}` to `{:?}`", ty, fallback);
2564 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2568 fn select_all_obligations_or_error(&self) {
2569 debug!("select_all_obligations_or_error");
2570 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2571 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2575 /// Select as many obligations as we can at present.
2576 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2577 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2578 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2582 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2583 /// returns a type of `&T`, but the actual type we assign to the
2584 /// *expression* is `T`. So this function just peels off the return
2585 /// type by one layer to yield `T`.
2586 fn make_overloaded_place_return_type(&self,
2587 method: MethodCallee<'tcx>)
2588 -> ty::TypeAndMut<'tcx>
2590 // extract method return type, which will be &T;
2591 let ret_ty = method.sig.output();
2593 // method returns &T, but the type as visible to user is T, so deref
2594 ret_ty.builtin_deref(true).unwrap()
2597 fn lookup_indexing(&self,
2599 base_expr: &'gcx hir::Expr,
2603 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2605 // FIXME(#18741) -- this is almost but not quite the same as the
2606 // autoderef that normal method probing does. They could likely be
2609 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2610 let mut result = None;
2611 while result.is_none() && autoderef.next().is_some() {
2612 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2614 autoderef.finalize(self);
2618 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2619 /// (and otherwise adjust) `base_expr`, looking for a type which either
2620 /// supports builtin indexing or overloaded indexing.
2621 /// This loop implements one step in that search; the autoderef loop
2622 /// is implemented by `lookup_indexing`.
2623 fn try_index_step(&self,
2625 base_expr: &hir::Expr,
2626 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2629 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2631 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2632 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2639 for &unsize in &[false, true] {
2640 let mut self_ty = adjusted_ty;
2642 // We only unsize arrays here.
2643 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2644 self_ty = self.tcx.mk_slice(element_ty);
2650 // If some lookup succeeds, write callee into table and extract index/element
2651 // type from the method signature.
2652 // If some lookup succeeded, install method in table
2653 let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
2654 let method = self.try_overloaded_place_op(
2655 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2657 let result = method.map(|ok| {
2658 debug!("try_index_step: success, using overloaded indexing");
2659 let method = self.register_infer_ok_obligations(ok);
2661 let mut adjustments = autoderef.adjust_steps(self, needs);
2662 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2663 let mutbl = match r_mutbl {
2664 hir::MutImmutable => AutoBorrowMutability::Immutable,
2665 hir::MutMutable => AutoBorrowMutability::Mutable {
2666 // Indexing can be desugared to a method call,
2667 // so maybe we could use two-phase here.
2668 // See the documentation of AllowTwoPhase for why that's
2669 // not the case today.
2670 allow_two_phase_borrow: AllowTwoPhase::No,
2673 adjustments.push(Adjustment {
2674 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2675 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2682 adjustments.push(Adjustment {
2683 kind: Adjust::Unsize,
2684 target: method.sig.inputs()[0]
2687 self.apply_adjustments(base_expr, adjustments);
2689 self.write_method_call(expr.hir_id, method);
2690 (input_ty, self.make_overloaded_place_return_type(method).ty)
2692 if result.is_some() {
2700 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2701 let (tr, name) = match (op, is_mut) {
2702 (PlaceOp::Deref, false) =>
2703 (self.tcx.lang_items().deref_trait(), "deref"),
2704 (PlaceOp::Deref, true) =>
2705 (self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
2706 (PlaceOp::Index, false) =>
2707 (self.tcx.lang_items().index_trait(), "index"),
2708 (PlaceOp::Index, true) =>
2709 (self.tcx.lang_items().index_mut_trait(), "index_mut"),
2711 (tr, ast::Ident::from_str(name))
2714 fn try_overloaded_place_op(&self,
2717 arg_tys: &[Ty<'tcx>],
2720 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2722 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2728 // Try Mut first, if needed.
2729 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2730 let method = match (needs, mut_tr) {
2731 (Needs::MutPlace, Some(trait_did)) => {
2732 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2737 // Otherwise, fall back to the immutable version.
2738 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2739 let method = match (method, imm_tr) {
2740 (None, Some(trait_did)) => {
2741 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2743 (method, _) => method,
2749 fn check_method_argument_types(&self,
2752 method: Result<MethodCallee<'tcx>, ()>,
2753 args_no_rcvr: &'gcx [hir::Expr],
2754 tuple_arguments: TupleArgumentsFlag,
2755 expected: Expectation<'tcx>)
2757 let has_error = match method {
2759 method.substs.references_error() || method.sig.references_error()
2764 let err_inputs = self.err_args(args_no_rcvr.len());
2766 let err_inputs = match tuple_arguments {
2767 DontTupleArguments => err_inputs,
2768 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2771 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2772 false, tuple_arguments, None);
2773 return self.tcx.types.err;
2776 let method = method.unwrap();
2777 // HACK(eddyb) ignore self in the definition (see above).
2778 let expected_arg_tys = self.expected_inputs_for_expected_output(
2781 method.sig.output(),
2782 &method.sig.inputs()[1..]
2784 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2785 args_no_rcvr, method.sig.variadic, tuple_arguments,
2786 self.tcx.hir().span_if_local(method.def_id));
2790 fn self_type_matches_expected_vid(
2792 trait_ref: ty::PolyTraitRef<'tcx>,
2793 expected_vid: ty::TyVid,
2795 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2797 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2798 trait_ref, self_ty, expected_vid
2801 ty::Infer(ty::TyVar(found_vid)) => {
2802 // FIXME: consider using `sub_root_var` here so we
2803 // can see through subtyping.
2804 let found_vid = self.root_var(found_vid);
2805 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2806 expected_vid == found_vid
2812 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2813 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2814 + Captures<'gcx> + 'b
2816 // FIXME: consider using `sub_root_var` here so we
2817 // can see through subtyping.
2818 let ty_var_root = self.root_var(self_ty);
2819 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2820 self_ty, ty_var_root,
2821 self.fulfillment_cx.borrow().pending_obligations());
2825 .pending_obligations()
2827 .filter_map(move |obligation| match obligation.predicate {
2828 ty::Predicate::Projection(ref data) =>
2829 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2830 ty::Predicate::Trait(ref data) =>
2831 Some((data.to_poly_trait_ref(), obligation)),
2832 ty::Predicate::Subtype(..) => None,
2833 ty::Predicate::RegionOutlives(..) => None,
2834 ty::Predicate::TypeOutlives(..) => None,
2835 ty::Predicate::WellFormed(..) => None,
2836 ty::Predicate::ObjectSafe(..) => None,
2837 ty::Predicate::ConstEvaluatable(..) => None,
2838 // N.B., this predicate is created by breaking down a
2839 // `ClosureType: FnFoo()` predicate, where
2840 // `ClosureType` represents some `Closure`. It can't
2841 // possibly be referring to the current closure,
2842 // because we haven't produced the `Closure` for
2843 // this closure yet; this is exactly why the other
2844 // code is looking for a self type of a unresolved
2845 // inference variable.
2846 ty::Predicate::ClosureKind(..) => None,
2847 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2850 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2851 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2852 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2856 /// Generic function that factors out common logic from function calls,
2857 /// method calls and overloaded operators.
2858 fn check_argument_types(&self,
2861 fn_inputs: &[Ty<'tcx>],
2862 mut expected_arg_tys: &[Ty<'tcx>],
2863 args: &'gcx [hir::Expr],
2865 tuple_arguments: TupleArgumentsFlag,
2866 def_span: Option<Span>) {
2869 // Grab the argument types, supplying fresh type variables
2870 // if the wrong number of arguments were supplied
2871 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2877 // All the input types from the fn signature must outlive the call
2878 // so as to validate implied bounds.
2879 for &fn_input_ty in fn_inputs {
2880 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2883 let expected_arg_count = fn_inputs.len();
2885 let param_count_error = |expected_count: usize,
2890 let mut err = tcx.sess.struct_span_err_with_code(sp,
2891 &format!("this function takes {}{} but {} {} supplied",
2892 if variadic {"at least "} else {""},
2893 potentially_plural_count(expected_count, "parameter"),
2894 potentially_plural_count(arg_count, "parameter"),
2895 if arg_count == 1 {"was"} else {"were"}),
2896 DiagnosticId::Error(error_code.to_owned()));
2898 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2899 err.span_label(def_s, "defined here");
2902 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2903 // remove closing `)` from the span
2904 let sugg_span = sugg_span.shrink_to_lo();
2905 err.span_suggestion(
2907 "expected the unit value `()`; create it with empty parentheses",
2909 Applicability::MachineApplicable);
2911 err.span_label(sp, format!("expected {}{}",
2912 if variadic {"at least "} else {""},
2913 potentially_plural_count(expected_count, "parameter")));
2918 let formal_tys = if tuple_arguments == TupleArguments {
2919 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2920 match tuple_type.sty {
2921 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2922 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2923 expected_arg_tys = &[];
2924 self.err_args(args.len())
2926 ty::Tuple(arg_types) => {
2927 expected_arg_tys = match expected_arg_tys.get(0) {
2928 Some(&ty) => match ty.sty {
2929 ty::Tuple(ref tys) => &tys,
2937 span_err!(tcx.sess, sp, E0059,
2938 "cannot use call notation; the first type parameter \
2939 for the function trait is neither a tuple nor unit");
2940 expected_arg_tys = &[];
2941 self.err_args(args.len())
2944 } else if expected_arg_count == supplied_arg_count {
2946 } else if variadic {
2947 if supplied_arg_count >= expected_arg_count {
2950 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2951 expected_arg_tys = &[];
2952 self.err_args(supplied_arg_count)
2955 // is the missing argument of type `()`?
2956 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2957 self.resolve_type_vars_if_possible(&expected_arg_tys[0]).is_unit()
2958 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2959 self.resolve_type_vars_if_possible(&fn_inputs[0]).is_unit()
2963 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2965 expected_arg_tys = &[];
2966 self.err_args(supplied_arg_count)
2968 // If there is no expectation, expect formal_tys.
2969 let expected_arg_tys = if !expected_arg_tys.is_empty() {
2975 debug!("check_argument_types: formal_tys={:?}",
2976 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
2978 // Check the arguments.
2979 // We do this in a pretty awful way: first we type-check any arguments
2980 // that are not closures, then we type-check the closures. This is so
2981 // that we have more information about the types of arguments when we
2982 // type-check the functions. This isn't really the right way to do this.
2983 for &check_closures in &[false, true] {
2984 debug!("check_closures={}", check_closures);
2986 // More awful hacks: before we check argument types, try to do
2987 // an "opportunistic" vtable resolution of any trait bounds on
2988 // the call. This helps coercions.
2990 self.select_obligations_where_possible(false);
2993 // For variadic functions, we don't have a declared type for all of
2994 // the arguments hence we only do our usual type checking with
2995 // the arguments who's types we do know.
2996 let t = if variadic {
2998 } else if tuple_arguments == TupleArguments {
3003 for (i, arg) in args.iter().take(t).enumerate() {
3004 // Warn only for the first loop (the "no closures" one).
3005 // Closure arguments themselves can't be diverging, but
3006 // a previous argument can, e.g., `foo(panic!(), || {})`.
3007 if !check_closures {
3008 self.warn_if_unreachable(arg.id, arg.span, "expression");
3011 let is_closure = match arg.node {
3012 ExprKind::Closure(..) => true,
3016 if is_closure != check_closures {
3020 debug!("checking the argument");
3021 let formal_ty = formal_tys[i];
3023 // The special-cased logic below has three functions:
3024 // 1. Provide as good of an expected type as possible.
3025 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3027 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3029 // 2. Coerce to the most detailed type that could be coerced
3030 // to, which is `expected_ty` if `rvalue_hint` returns an
3031 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3032 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3033 // We're processing function arguments so we definitely want to use
3034 // two-phase borrows.
3035 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3037 // 3. Relate the expected type and the formal one,
3038 // if the expected type was used for the coercion.
3039 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3043 // We also need to make sure we at least write the ty of the other
3044 // arguments which we skipped above.
3046 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3047 use structured_errors::{VariadicError, StructuredDiagnostic};
3048 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3051 for arg in args.iter().skip(expected_arg_count) {
3052 let arg_ty = self.check_expr(&arg);
3054 // There are a few types which get autopromoted when passed via varargs
3055 // in C but we just error out instead and require explicit casts.
3056 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3058 ty::Float(ast::FloatTy::F32) => {
3059 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3061 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3062 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3064 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3065 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3068 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3069 let ptr_ty = self.resolve_type_vars_if_possible(&ptr_ty);
3070 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3078 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3079 vec![self.tcx.types.err; len]
3082 // AST fragment checking
3085 expected: Expectation<'tcx>)
3091 ast::LitKind::Str(..) => tcx.mk_static_str(),
3092 ast::LitKind::ByteStr(ref v) => {
3093 tcx.mk_imm_ref(tcx.types.re_static,
3094 tcx.mk_array(tcx.types.u8, v.len() as u64))
3096 ast::LitKind::Byte(_) => tcx.types.u8,
3097 ast::LitKind::Char(_) => tcx.types.char,
3098 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3099 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3100 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3101 let opt_ty = expected.to_option(self).and_then(|ty| {
3103 ty::Int(_) | ty::Uint(_) => Some(ty),
3104 ty::Char => Some(tcx.types.u8),
3105 ty::RawPtr(..) => Some(tcx.types.usize),
3106 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3110 opt_ty.unwrap_or_else(
3111 || tcx.mk_int_var(self.next_int_var_id()))
3113 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3114 ast::LitKind::FloatUnsuffixed(_) => {
3115 let opt_ty = expected.to_option(self).and_then(|ty| {
3117 ty::Float(_) => Some(ty),
3121 opt_ty.unwrap_or_else(
3122 || tcx.mk_float_var(self.next_float_var_id()))
3124 ast::LitKind::Bool(_) => tcx.types.bool,
3125 ast::LitKind::Err(_) => tcx.types.err,
3129 fn check_expr_eq_type(&self,
3130 expr: &'gcx hir::Expr,
3131 expected: Ty<'tcx>) {
3132 let ty = self.check_expr_with_hint(expr, expected);
3133 self.demand_eqtype(expr.span, expected, ty);
3136 pub fn check_expr_has_type_or_error(&self,
3137 expr: &'gcx hir::Expr,
3138 expected: Ty<'tcx>) -> Ty<'tcx> {
3139 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3142 fn check_expr_meets_expectation_or_error(&self,
3143 expr: &'gcx hir::Expr,
3144 expected: Expectation<'tcx>) -> Ty<'tcx> {
3145 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3146 let mut ty = self.check_expr_with_expectation(expr, expected);
3148 // While we don't allow *arbitrary* coercions here, we *do* allow
3149 // coercions from ! to `expected`.
3151 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3152 "expression with never type wound up being adjusted");
3153 let adj_ty = self.next_diverging_ty_var(
3154 TypeVariableOrigin::AdjustmentType(expr.span));
3155 self.apply_adjustments(expr, vec![Adjustment {
3156 kind: Adjust::NeverToAny,
3162 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3163 // Add help to type error if this is an `if` condition with an assignment.
3164 if let (ExpectIfCondition, &ExprKind::Assign(ref lhs, ref rhs))
3165 = (expected, &expr.node)
3167 let msg = "try comparing for equality";
3168 if let (Ok(left), Ok(right)) = (
3169 self.tcx.sess.source_map().span_to_snippet(lhs.span),
3170 self.tcx.sess.source_map().span_to_snippet(rhs.span))
3172 err.span_suggestion(
3175 format!("{} == {}", left, right),
3176 Applicability::MaybeIncorrect);
3186 fn check_expr_coercable_to_type(&self,
3187 expr: &'gcx hir::Expr,
3188 expected: Ty<'tcx>) -> Ty<'tcx> {
3189 let ty = self.check_expr_with_hint(expr, expected);
3190 // checks don't need two phase
3191 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3194 fn check_expr_with_hint(&self,
3195 expr: &'gcx hir::Expr,
3196 expected: Ty<'tcx>) -> Ty<'tcx> {
3197 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3200 fn check_expr_with_expectation(&self,
3201 expr: &'gcx hir::Expr,
3202 expected: Expectation<'tcx>) -> Ty<'tcx> {
3203 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3206 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3207 self.check_expr_with_expectation(expr, NoExpectation)
3210 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3211 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3214 // Determine the `Self` type, using fresh variables for all variables
3215 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3216 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3218 pub fn impl_self_ty(&self,
3219 span: Span, // (potential) receiver for this impl
3221 -> TypeAndSubsts<'tcx> {
3222 let ity = self.tcx.type_of(did);
3223 debug!("impl_self_ty: ity={:?}", ity);
3225 let substs = self.fresh_substs_for_item(span, did);
3226 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3228 TypeAndSubsts { substs: substs, ty: substd_ty }
3231 /// Unifies the output type with the expected type early, for more coercions
3232 /// and forward type information on the input expressions.
3233 fn expected_inputs_for_expected_output(&self,
3235 expected_ret: Expectation<'tcx>,
3236 formal_ret: Ty<'tcx>,
3237 formal_args: &[Ty<'tcx>])
3239 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3240 let ret_ty = match expected_ret.only_has_type(self) {
3242 None => return Vec::new()
3244 let expect_args = self.fudge_regions_if_ok(&RegionVariableOrigin::Coercion(call_span), || {
3245 // Attempt to apply a subtyping relationship between the formal
3246 // return type (likely containing type variables if the function
3247 // is polymorphic) and the expected return type.
3248 // No argument expectations are produced if unification fails.
3249 let origin = self.misc(call_span);
3250 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3252 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3253 // to identity so the resulting type is not constrained.
3256 // Process any obligations locally as much as
3257 // we can. We don't care if some things turn
3258 // out unconstrained or ambiguous, as we're
3259 // just trying to get hints here.
3260 self.save_and_restore_in_snapshot_flag(|_| {
3261 let mut fulfill = TraitEngine::new(self.tcx);
3262 for obligation in ok.obligations {
3263 fulfill.register_predicate_obligation(self, obligation);
3265 fulfill.select_where_possible(self)
3266 }).map_err(|_| ())?;
3268 Err(_) => return Err(()),
3271 // Record all the argument types, with the substitutions
3272 // produced from the above subtyping unification.
3273 Ok(formal_args.iter().map(|ty| {
3274 self.resolve_type_vars_if_possible(ty)
3276 }).unwrap_or_default();
3277 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3278 formal_args, formal_ret,
3279 expect_args, expected_ret);
3283 // Checks a method call.
3284 fn check_method_call(&self,
3285 expr: &'gcx hir::Expr,
3286 segment: &hir::PathSegment,
3288 args: &'gcx [hir::Expr],
3289 expected: Expectation<'tcx>,
3290 needs: Needs) -> Ty<'tcx> {
3291 let rcvr = &args[0];
3292 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3293 // no need to check for bot/err -- callee does that
3294 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3296 let method = match self.lookup_method(rcvr_t,
3302 self.write_method_call(expr.hir_id, method);
3306 if segment.ident.name != keywords::Invalid.name() {
3307 self.report_method_error(span,
3310 SelfSource::MethodCall(rcvr),
3318 // Call the generic checker.
3319 self.check_method_argument_types(span,
3327 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3331 .unwrap_or_else(|| span_bug!(return_expr.span,
3332 "check_return_expr called outside fn body"));
3334 let ret_ty = ret_coercion.borrow().expected_ty();
3335 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3336 ret_coercion.borrow_mut()
3338 &self.cause(return_expr.span,
3339 ObligationCauseCode::ReturnType(return_expr.id)),
3344 // A generic function for checking the 'then' and 'else' clauses in an 'if'
3345 // or 'if-else' expression.
3346 fn check_then_else(&self,
3347 cond_expr: &'gcx hir::Expr,
3348 then_expr: &'gcx hir::Expr,
3349 opt_else_expr: Option<&'gcx hir::Expr>,
3351 expected: Expectation<'tcx>) -> Ty<'tcx> {
3352 let cond_ty = self.check_expr_meets_expectation_or_error(cond_expr, ExpectIfCondition);
3353 let cond_diverges = self.diverges.get();
3354 self.diverges.set(Diverges::Maybe);
3356 let expected = expected.adjust_for_branches(self);
3357 let then_ty = self.check_expr_with_expectation(then_expr, expected);
3358 let then_diverges = self.diverges.get();
3359 self.diverges.set(Diverges::Maybe);
3361 // We've already taken the expected type's preferences
3362 // into account when typing the `then` branch. To figure
3363 // out the initial shot at a LUB, we thus only consider
3364 // `expected` if it represents a *hard* constraint
3365 // (`only_has_type`); otherwise, we just go with a
3366 // fresh type variable.
3367 let coerce_to_ty = expected.coercion_target_type(self, sp);
3368 let mut coerce: DynamicCoerceMany = CoerceMany::new(coerce_to_ty);
3370 coerce.coerce(self, &self.misc(sp), then_expr, then_ty);
3372 if let Some(else_expr) = opt_else_expr {
3373 let else_ty = self.check_expr_with_expectation(else_expr, expected);
3374 let else_diverges = self.diverges.get();
3376 let mut outer_sp = if self.tcx.sess.source_map().is_multiline(sp) {
3377 // The `if`/`else` isn't in one line in the output, include some context to make it
3378 // clear it is an if/else expression:
3380 // LL | let x = if true {
3383 // || ----- expected because of this
3386 // || ^^^^^ expected i32, found u32
3388 // ||_____- if and else have incompatible types
3392 // The entire expression is in one line, only point at the arms
3394 // LL | let x = if true { 10i32 } else { 10u32 };
3395 // | ----- ^^^^^ expected i32, found u32
3397 // | expected because of this
3401 let mut remove_semicolon = None;
3402 let error_sp = if let ExprKind::Block(block, _) = &else_expr.node {
3403 if let Some(expr) = &block.expr {
3405 } else if let Some(stmt) = block.stmts.last() {
3406 // possibly incorrect trailing `;` in the else arm
3407 remove_semicolon = self.could_remove_semicolon(block, then_ty);
3409 } else { // empty block, point at its entirety
3410 // Avoid overlapping spans that aren't as readable:
3412 // 2 | let x = if true {
3415 // | | - expected because of this
3422 // | |______if and else have incompatible types
3423 // | expected integer, found ()
3425 // by not pointing at the entire expression:
3427 // 2 | let x = if true {
3428 // | ------- if and else have incompatible types
3430 // | - expected because of this
3435 // | |_____^ expected integer, found ()
3437 if outer_sp.is_some() {
3438 outer_sp = Some(self.tcx.sess.source_map().def_span(sp));
3442 } else { // shouldn't happen unless the parser has done something weird
3445 let then_sp = if let ExprKind::Block(block, _) = &then_expr.node {
3446 if let Some(expr) = &block.expr {
3448 } else if let Some(stmt) = block.stmts.last() {
3449 // possibly incorrect trailing `;` in the else arm
3450 remove_semicolon = remove_semicolon.or(
3451 self.could_remove_semicolon(block, else_ty));
3453 } else { // empty block, point at its entirety
3454 outer_sp = None; // same as in `error_sp`, cleanup output
3457 } else { // shouldn't happen unless the parser has done something weird
3461 let if_cause = self.cause(error_sp, ObligationCauseCode::IfExpression {
3464 semicolon: remove_semicolon,
3467 coerce.coerce(self, &if_cause, else_expr, else_ty);
3469 // We won't diverge unless both branches do (or the condition does).
3470 self.diverges.set(cond_diverges | then_diverges & else_diverges);
3472 let else_cause = self.cause(sp, ObligationCauseCode::IfExpressionWithNoElse);
3473 coerce.coerce_forced_unit(self, &else_cause, &mut |_| (), true);
3475 // If the condition is false we can't diverge.
3476 self.diverges.set(cond_diverges);
3479 let result_ty = coerce.complete(self);
3480 if cond_ty.references_error() {
3487 // Check field access expressions
3488 fn check_field(&self,
3489 expr: &'gcx hir::Expr,
3491 base: &'gcx hir::Expr,
3492 field: ast::Ident) -> Ty<'tcx> {
3493 let expr_t = self.check_expr_with_needs(base, needs);
3494 let expr_t = self.structurally_resolved_type(base.span,
3496 let mut private_candidate = None;
3497 let mut autoderef = self.autoderef(expr.span, expr_t);
3498 while let Some((base_t, _)) = autoderef.next() {
3500 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3501 debug!("struct named {:?}", base_t);
3502 let (ident, def_scope) =
3503 self.tcx.adjust_ident(field, base_def.did, self.body_id);
3504 let fields = &base_def.non_enum_variant().fields;
3505 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3506 let field = &fields[index];
3507 let field_ty = self.field_ty(expr.span, field, substs);
3508 // Save the index of all fields regardless of their visibility in case
3509 // of error recovery.
3510 self.write_field_index(expr.id, index);
3511 if field.vis.is_accessible_from(def_scope, self.tcx) {
3512 let adjustments = autoderef.adjust_steps(self, needs);
3513 self.apply_adjustments(base, adjustments);
3514 autoderef.finalize(self);
3516 self.tcx.check_stability(field.did, Some(expr.id), expr.span);
3519 private_candidate = Some((base_def.did, field_ty));
3522 ty::Tuple(ref tys) => {
3523 let fstr = field.as_str();
3524 if let Ok(index) = fstr.parse::<usize>() {
3525 if fstr == index.to_string() {
3526 if let Some(field_ty) = tys.get(index) {
3527 let adjustments = autoderef.adjust_steps(self, needs);
3528 self.apply_adjustments(base, adjustments);
3529 autoderef.finalize(self);
3531 self.write_field_index(expr.id, index);
3540 autoderef.unambiguous_final_ty(self);
3542 if let Some((did, field_ty)) = private_candidate {
3543 let struct_path = self.tcx().item_path_str(did);
3544 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3545 "field `{}` of struct `{}` is private",
3546 field, struct_path);
3547 // Also check if an accessible method exists, which is often what is meant.
3548 if self.method_exists(field, expr_t, expr.id, false) && !self.expr_in_place(expr.id) {
3549 self.suggest_method_call(
3551 &format!("a method `{}` also exists, call it with parentheses", field),
3559 } else if field.name == keywords::Invalid.name() {
3560 self.tcx().types.err
3561 } else if self.method_exists(field, expr_t, expr.id, true) {
3562 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3563 "attempted to take value of method `{}` on type `{}`",
3566 if !self.expr_in_place(expr.id) {
3567 self.suggest_method_call(
3569 "use parentheses to call the method",
3575 err.help("methods are immutable and cannot be assigned to");
3579 self.tcx().types.err
3581 if !expr_t.is_primitive_ty() {
3582 let mut err = self.no_such_field_err(field.span, field, expr_t);
3585 ty::Adt(def, _) if !def.is_enum() => {
3586 if let Some(suggested_field_name) =
3587 Self::suggest_field_name(def.non_enum_variant(),
3588 &field.as_str(), vec![]) {
3589 err.span_suggestion(
3591 "a field with a similar name exists",
3592 suggested_field_name.to_string(),
3593 Applicability::MaybeIncorrect,
3596 err.span_label(field.span, "unknown field");
3597 let struct_variant_def = def.non_enum_variant();
3598 let field_names = self.available_field_names(struct_variant_def);
3599 if !field_names.is_empty() {
3600 err.note(&format!("available fields are: {}",
3601 self.name_series_display(field_names)));
3605 ty::Array(_, len) => {
3606 if let (Some(len), Ok(user_index)) = (
3607 len.assert_usize(self.tcx),
3608 field.as_str().parse::<u64>()
3610 let base = self.tcx.sess.source_map()
3611 .span_to_snippet(base.span)
3612 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3613 let help = "instead of using tuple indexing, use array indexing";
3614 let suggestion = format!("{}[{}]", base, field);
3615 let applicability = if len < user_index {
3616 Applicability::MachineApplicable
3618 Applicability::MaybeIncorrect
3620 err.span_suggestion(
3621 expr.span, help, suggestion, applicability
3626 let base = self.tcx.sess.source_map()
3627 .span_to_snippet(base.span)
3628 .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
3629 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3630 let suggestion = format!("(*{}).{}", base, field);
3631 err.span_suggestion(
3635 Applicability::MaybeIncorrect,
3642 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3643 "`{}` is a primitive type and therefore doesn't have fields",
3646 self.tcx().types.err
3650 // Return an hint about the closest match in field names
3651 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3653 skip: Vec<LocalInternedString>)
3655 let names = variant.fields.iter().filter_map(|field| {
3656 // ignore already set fields and private fields from non-local crates
3657 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3658 (variant.did.krate != LOCAL_CRATE && field.vis != Visibility::Public) {
3661 Some(&field.ident.name)
3665 find_best_match_for_name(names, field, None)
3668 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3669 variant.fields.iter().filter(|field| {
3670 let def_scope = self.tcx.adjust_ident(field.ident, variant.did, self.body_id).1;
3671 field.vis.is_accessible_from(def_scope, self.tcx)
3673 .map(|field| field.ident.name)
3677 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3678 // dynamic limit, to never omit just one field
3679 let limit = if names.len() == 6 { 6 } else { 5 };
3680 let mut display = names.iter().take(limit)
3681 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3682 if names.len() > limit {
3683 display = format!("{} ... and {} others", display, names.len() - limit);
3688 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS)
3689 -> DiagnosticBuilder {
3690 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3691 "no field `{}` on type `{}`",
3695 fn report_unknown_field(&self,
3697 variant: &'tcx ty::VariantDef,
3699 skip_fields: &[hir::Field],
3701 let mut err = self.type_error_struct_with_diag(
3703 |actual| match ty.sty {
3704 ty::Adt(adt, ..) if adt.is_enum() => {
3705 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3706 "{} `{}::{}` has no field named `{}`",
3707 kind_name, actual, variant.ident, field.ident)
3710 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3711 "{} `{}` has no field named `{}`",
3712 kind_name, actual, field.ident)
3716 // prevent all specified fields from being suggested
3717 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3718 if let Some(field_name) = Self::suggest_field_name(variant,
3719 &field.ident.as_str(),
3720 skip_fields.collect()) {
3721 err.span_suggestion(
3723 "a field with a similar name exists",
3724 field_name.to_string(),
3725 Applicability::MaybeIncorrect,
3729 ty::Adt(adt, ..) => {
3731 err.span_label(field.ident.span,
3732 format!("`{}::{}` does not have this field",
3733 ty, variant.ident));
3735 err.span_label(field.ident.span,
3736 format!("`{}` does not have this field", ty));
3738 let available_field_names = self.available_field_names(variant);
3739 if !available_field_names.is_empty() {
3740 err.note(&format!("available fields are: {}",
3741 self.name_series_display(available_field_names)));
3744 _ => bug!("non-ADT passed to report_unknown_field")
3750 fn check_expr_struct_fields(&self,
3752 expected: Expectation<'tcx>,
3753 expr_id: ast::NodeId,
3755 variant: &'tcx ty::VariantDef,
3756 ast_fields: &'gcx [hir::Field],
3757 check_completeness: bool) -> bool {
3761 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3762 .get(0).cloned().unwrap_or(adt_ty);
3763 // re-link the regions that EIfEO can erase.
3764 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3766 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3767 &ty::Adt(adt, substs) => {
3768 (substs, adt.adt_kind(), adt.variant_descr())
3770 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3773 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3774 (field.ident.modern(), (i, field))
3775 ).collect::<FxHashMap<_, _>>();
3777 let mut seen_fields = FxHashMap::default();
3779 let mut error_happened = false;
3781 // Type-check each field.
3782 for field in ast_fields {
3783 let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
3784 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3785 seen_fields.insert(ident, field.span);
3786 self.write_field_index(field.id, i);
3788 // We don't look at stability attributes on
3789 // struct-like enums (yet...), but it's definitely not
3790 // a bug to have constructed one.
3791 if adt_kind != AdtKind::Enum {
3792 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3795 self.field_ty(field.span, v_field, substs)
3797 error_happened = true;
3798 if let Some(prev_span) = seen_fields.get(&ident) {
3799 let mut err = struct_span_err!(self.tcx.sess,
3802 "field `{}` specified more than once",
3805 err.span_label(field.ident.span, "used more than once");
3806 err.span_label(*prev_span, format!("first use of `{}`", ident));
3810 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3816 // Make sure to give a type to the field even if there's
3817 // an error, so we can continue type-checking.
3818 self.check_expr_coercable_to_type(&field.expr, field_type);
3821 // Make sure the programmer specified correct number of fields.
3822 if kind_name == "union" {
3823 if ast_fields.len() != 1 {
3824 tcx.sess.span_err(span, "union expressions should have exactly one field");
3826 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3827 let len = remaining_fields.len();
3829 let mut displayable_field_names = remaining_fields
3831 .map(|ident| ident.as_str())
3832 .collect::<Vec<_>>();
3834 displayable_field_names.sort();
3836 let truncated_fields_error = if len <= 3 {
3839 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3842 let remaining_fields_names = displayable_field_names.iter().take(3)
3843 .map(|n| format!("`{}`", n))
3844 .collect::<Vec<_>>()
3847 struct_span_err!(tcx.sess, span, E0063,
3848 "missing field{} {}{} in initializer of `{}`",
3849 if remaining_fields.len() == 1 { "" } else { "s" },
3850 remaining_fields_names,
3851 truncated_fields_error,
3853 .span_label(span, format!("missing {}{}",
3854 remaining_fields_names,
3855 truncated_fields_error))
3861 fn check_struct_fields_on_error(&self,
3862 fields: &'gcx [hir::Field],
3863 base_expr: &'gcx Option<P<hir::Expr>>) {
3864 for field in fields {
3865 self.check_expr(&field.expr);
3867 if let Some(ref base) = *base_expr {
3868 self.check_expr(&base);
3872 pub fn check_struct_path(&self,
3874 node_id: ast::NodeId)
3875 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3876 let path_span = match *qpath {
3877 QPath::Resolved(_, ref path) => path.span,
3878 QPath::TypeRelative(ref qself, _) => qself.span
3880 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
3881 let variant = match def {
3883 self.set_tainted_by_errors();
3886 Def::Variant(..) => {
3888 ty::Adt(adt, substs) => {
3889 Some((adt.variant_of_def(def), adt.did, substs))
3891 _ => bug!("unexpected type: {:?}", ty.sty)
3894 Def::Struct(..) | Def::Union(..) | Def::TyAlias(..) |
3895 Def::AssociatedTy(..) | Def::SelfTy(..) => {
3897 ty::Adt(adt, substs) if !adt.is_enum() => {
3898 Some((adt.non_enum_variant(), adt.did, substs))
3903 _ => bug!("unexpected definition: {:?}", def)
3906 if let Some((variant, did, substs)) = variant {
3907 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3908 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
3909 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3911 // Check bounds on type arguments used in the path.
3912 let bounds = self.instantiate_bounds(path_span, did, substs);
3913 let cause = traits::ObligationCause::new(path_span, self.body_id,
3914 traits::ItemObligation(did));
3915 self.add_obligations_for_parameters(cause, &bounds);
3919 struct_span_err!(self.tcx.sess, path_span, E0071,
3920 "expected struct, variant or union type, found {}",
3921 ty.sort_string(self.tcx))
3922 .span_label(path_span, "not a struct")
3928 fn check_expr_struct(&self,
3930 expected: Expectation<'tcx>,
3932 fields: &'gcx [hir::Field],
3933 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3935 // Find the relevant variant
3936 let (variant, adt_ty) =
3937 if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
3940 self.check_struct_fields_on_error(fields, base_expr);
3941 return self.tcx.types.err;
3944 let path_span = match *qpath {
3945 QPath::Resolved(_, ref path) => path.span,
3946 QPath::TypeRelative(ref qself, _) => qself.span
3949 // Prohibit struct expressions when non-exhaustive flag is set.
3950 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3951 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3952 span_err!(self.tcx.sess, expr.span, E0639,
3953 "cannot create non-exhaustive {} using struct expression",
3954 adt.variant_descr());
3957 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
3958 variant, fields, base_expr.is_none());
3959 if let &Some(ref base_expr) = base_expr {
3960 // If check_expr_struct_fields hit an error, do not attempt to populate
3961 // the fields with the base_expr. This could cause us to hit errors later
3962 // when certain fields are assumed to exist that in fact do not.
3963 if !error_happened {
3964 self.check_expr_has_type_or_error(base_expr, adt_ty);
3966 ty::Adt(adt, substs) if adt.is_struct() => {
3967 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3968 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3973 .fru_field_types_mut()
3974 .insert(expr.hir_id, fru_field_types);
3977 span_err!(self.tcx.sess, base_expr.span, E0436,
3978 "functional record update syntax requires a struct");
3983 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3989 /// If an expression has any sub-expressions that result in a type error,
3990 /// inspecting that expression's type with `ty.references_error()` will return
3991 /// true. Likewise, if an expression is known to diverge, inspecting its
3992 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3993 /// strict, _|_ can appear in the type of an expression that does not,
3994 /// itself, diverge: for example, fn() -> _|_.)
3995 /// Note that inspecting a type's structure *directly* may expose the fact
3996 /// that there are actually multiple representations for `Error`, so avoid
3997 /// that when err needs to be handled differently.
3998 fn check_expr_with_expectation_and_needs(&self,
3999 expr: &'gcx hir::Expr,
4000 expected: Expectation<'tcx>,
4001 needs: Needs) -> Ty<'tcx> {
4002 debug!(">> type-checking: expr={:?} expected={:?}",
4005 // Warn for expressions after diverging siblings.
4006 self.warn_if_unreachable(expr.id, expr.span, "expression");
4008 // Hide the outer diverging and has_errors flags.
4009 let old_diverges = self.diverges.get();
4010 let old_has_errors = self.has_errors.get();
4011 self.diverges.set(Diverges::Maybe);
4012 self.has_errors.set(false);
4014 let ty = self.check_expr_kind(expr, expected, needs);
4016 // Warn for non-block expressions with diverging children.
4018 ExprKind::Block(..) |
4019 ExprKind::Loop(..) | ExprKind::While(..) |
4020 ExprKind::If(..) | ExprKind::Match(..) => {}
4022 _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
4025 // Any expression that produces a value of type `!` must have diverged
4027 self.diverges.set(self.diverges.get() | Diverges::Always);
4030 // Record the type, which applies it effects.
4031 // We need to do this after the warning above, so that
4032 // we don't warn for the diverging expression itself.
4033 self.write_ty(expr.hir_id, ty);
4035 // Combine the diverging and has_error flags.
4036 self.diverges.set(self.diverges.get() | old_diverges);
4037 self.has_errors.set(self.has_errors.get() | old_has_errors);
4039 debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
4040 debug!("... {:?}, expected is {:?}", ty, expected);
4047 expr: &'gcx hir::Expr,
4048 expected: Expectation<'tcx>,
4052 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
4061 ExprKind::Box(ref subexpr) => {
4062 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
4064 ty::Adt(def, _) if def.is_box()
4065 => Expectation::rvalue_hint(self, ty.boxed_ty()),
4069 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
4070 tcx.mk_box(referent_ty)
4073 ExprKind::Lit(ref lit) => {
4074 self.check_lit(&lit, expected)
4076 ExprKind::Binary(op, ref lhs, ref rhs) => {
4077 self.check_binop(expr, op, lhs, rhs)
4079 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
4080 self.check_binop_assign(expr, op, lhs, rhs)
4082 ExprKind::Unary(unop, ref oprnd) => {
4083 let expected_inner = match unop {
4084 hir::UnNot | hir::UnNeg => {
4091 let needs = match unop {
4092 hir::UnDeref => needs,
4095 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
4099 if !oprnd_t.references_error() {
4100 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
4103 if let Some(mt) = oprnd_t.builtin_deref(true) {
4105 } else if let Some(ok) = self.try_overloaded_deref(
4106 expr.span, oprnd_t, needs) {
4107 let method = self.register_infer_ok_obligations(ok);
4108 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
4109 let mutbl = match mutbl {
4110 hir::MutImmutable => AutoBorrowMutability::Immutable,
4111 hir::MutMutable => AutoBorrowMutability::Mutable {
4112 // (It shouldn't actually matter for unary ops whether
4113 // we enable two-phase borrows or not, since a unary
4114 // op has no additional operands.)
4115 allow_two_phase_borrow: AllowTwoPhase::No,
4118 self.apply_adjustments(oprnd, vec![Adjustment {
4119 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4120 target: method.sig.inputs()[0]
4123 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4124 self.write_method_call(expr.hir_id, method);
4126 type_error_struct!(tcx.sess, expr.span, oprnd_t, E0614,
4127 "type `{}` cannot be dereferenced",
4129 oprnd_t = tcx.types.err;
4133 let result = self.check_user_unop(expr, oprnd_t, unop);
4134 // If it's builtin, we can reuse the type, this helps inference.
4135 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4140 let result = self.check_user_unop(expr, oprnd_t, unop);
4141 // If it's builtin, we can reuse the type, this helps inference.
4142 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4150 ExprKind::AddrOf(mutbl, ref oprnd) => {
4151 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4153 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4154 if oprnd.is_place_expr() {
4155 // Places may legitimately have unsized types.
4156 // For example, dereferences of a fat pointer and
4157 // the last field of a struct can be unsized.
4160 Expectation::rvalue_hint(self, ty)
4166 let needs = Needs::maybe_mut_place(mutbl);
4167 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4169 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4170 if tm.ty.references_error() {
4173 // Note: at this point, we cannot say what the best lifetime
4174 // is to use for resulting pointer. We want to use the
4175 // shortest lifetime possible so as to avoid spurious borrowck
4176 // errors. Moreover, the longest lifetime will depend on the
4177 // precise details of the value whose address is being taken
4178 // (and how long it is valid), which we don't know yet until type
4179 // inference is complete.
4181 // Therefore, here we simply generate a region variable. The
4182 // region inferencer will then select the ultimate value.
4183 // Finally, borrowck is charged with guaranteeing that the
4184 // value whose address was taken can actually be made to live
4185 // as long as it needs to live.
4186 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4187 tcx.mk_ref(region, tm)
4190 ExprKind::Path(ref qpath) => {
4191 let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
4192 let ty = match def {
4194 self.set_tainted_by_errors();
4197 Def::VariantCtor(_, CtorKind::Fictive) => {
4198 report_unexpected_variant_def(tcx, &def, expr.span, qpath);
4201 _ => self.instantiate_value_path(segs, opt_ty, def, expr.span, id).0,
4204 if let ty::FnDef(..) = ty.sty {
4205 let fn_sig = ty.fn_sig(tcx);
4206 if !tcx.features().unsized_locals {
4207 // We want to remove some Sized bounds from std functions,
4208 // but don't want to expose the removal to stable Rust.
4209 // i.e., we don't want to allow
4215 // to work in stable even if the Sized bound on `drop` is relaxed.
4216 for i in 0..fn_sig.inputs().skip_binder().len() {
4217 // We just want to check sizedness, so instead of introducing
4218 // placeholder lifetimes with probing, we just replace higher lifetimes
4220 let input = self.replace_bound_vars_with_fresh_vars(
4222 infer::LateBoundRegionConversionTime::FnCall,
4223 &fn_sig.input(i)).0;
4224 self.require_type_is_sized_deferred(input, expr.span,
4225 traits::SizedArgumentType);
4228 // Here we want to prevent struct constructors from returning unsized types.
4229 // There were two cases this happened: fn pointer coercion in stable
4230 // and usual function call in presense of unsized_locals.
4231 // Also, as we just want to check sizedness, instead of introducing
4232 // placeholder lifetimes with probing, we just replace higher lifetimes
4234 let output = self.replace_bound_vars_with_fresh_vars(
4236 infer::LateBoundRegionConversionTime::FnCall,
4237 &fn_sig.output()).0;
4238 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4241 // We always require that the type provided as the value for
4242 // a type parameter outlives the moment of instantiation.
4243 let substs = self.tables.borrow().node_substs(expr.hir_id);
4244 self.add_wf_bounds(substs, expr);
4248 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4249 for expr in outputs.iter().chain(inputs.iter()) {
4250 self.check_expr(expr);
4254 ExprKind::Break(destination, ref expr_opt) => {
4255 if let Ok(target_id) = destination.target_id {
4257 if let Some(ref e) = *expr_opt {
4258 // If this is a break with a value, we need to type-check
4259 // the expression. Get an expected type from the loop context.
4260 let opt_coerce_to = {
4261 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4262 enclosing_breakables.find_breakable(target_id)
4265 .map(|coerce| coerce.expected_ty())
4268 // If the loop context is not a `loop { }`, then break with
4269 // a value is illegal, and `opt_coerce_to` will be `None`.
4270 // Just set expectation to error in that case.
4271 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4273 // Recurse without `enclosing_breakables` borrowed.
4274 e_ty = self.check_expr_with_hint(e, coerce_to);
4275 cause = self.misc(e.span);
4277 // Otherwise, this is a break *without* a value. That's
4278 // always legal, and is equivalent to `break ()`.
4279 e_ty = tcx.mk_unit();
4280 cause = self.misc(expr.span);
4283 // Now that we have type-checked `expr_opt`, borrow
4284 // the `enclosing_loops` field and let's coerce the
4285 // type of `expr_opt` into what is expected.
4286 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4287 let ctxt = enclosing_breakables.find_breakable(target_id);
4288 if let Some(ref mut coerce) = ctxt.coerce {
4289 if let Some(ref e) = *expr_opt {
4290 coerce.coerce(self, &cause, e, e_ty);
4292 assert!(e_ty.is_unit());
4293 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4296 // If `ctxt.coerce` is `None`, we can just ignore
4297 // the type of the expresison. This is because
4298 // either this was a break *without* a value, in
4299 // which case it is always a legal type (`()`), or
4300 // else an error would have been flagged by the
4301 // `loops` pass for using break with an expression
4302 // where you are not supposed to.
4303 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4306 ctxt.may_break = true;
4308 // the type of a `break` is always `!`, since it diverges
4311 // Otherwise, we failed to find the enclosing loop;
4312 // this can only happen if the `break` was not
4313 // inside a loop at all, which is caught by the
4314 // loop-checking pass.
4315 if self.tcx.sess.err_count() == 0 {
4316 self.tcx.sess.delay_span_bug(expr.span,
4317 "break was outside loop, but no error was emitted");
4320 // We still need to assign a type to the inner expression to
4321 // prevent the ICE in #43162.
4322 if let Some(ref e) = *expr_opt {
4323 self.check_expr_with_hint(e, tcx.types.err);
4325 // ... except when we try to 'break rust;'.
4326 // ICE this expression in particular (see #43162).
4327 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4328 if path.segments.len() == 1 && path.segments[0].ident.name == "rust" {
4329 fatally_break_rust(self.tcx.sess);
4333 // There was an error; make type-check fail.
4338 ExprKind::Continue(destination) => {
4339 if destination.target_id.is_ok() {
4342 // There was an error; make type-check fail.
4346 ExprKind::Ret(ref expr_opt) => {
4347 if self.ret_coercion.is_none() {
4348 struct_span_err!(self.tcx.sess, expr.span, E0572,
4349 "return statement outside of function body").emit();
4350 } else if let Some(ref e) = *expr_opt {
4351 if self.ret_coercion_span.borrow().is_none() {
4352 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4354 self.check_return_expr(e);
4356 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4357 if self.ret_coercion_span.borrow().is_none() {
4358 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4360 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4361 if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
4362 coercion.coerce_forced_unit(
4367 fn_decl.output.span(),
4369 "expected `{}` because of this return type",
4377 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4382 ExprKind::Assign(ref lhs, ref rhs) => {
4383 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4385 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4388 ExpectIfCondition => {
4389 self.tcx.sess.delay_span_bug(lhs.span, "invalid lhs expression in if;\
4390 expected error elsehwere");
4393 // Only check this if not in an `if` condition, as the
4394 // mistyped comparison help is more appropriate.
4395 if !lhs.is_place_expr() {
4396 struct_span_err!(self.tcx.sess, expr.span, E0070,
4397 "invalid left-hand side expression")
4398 .span_label(expr.span, "left-hand of expression not valid")
4404 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4406 if lhs_ty.references_error() || rhs_ty.references_error() {
4412 ExprKind::If(ref cond, ref then_expr, ref opt_else_expr) => {
4413 self.check_then_else(&cond, then_expr, opt_else_expr.as_ref().map(|e| &**e),
4414 expr.span, expected)
4416 ExprKind::While(ref cond, ref body, _) => {
4417 let ctxt = BreakableCtxt {
4418 // cannot use break with a value from a while loop
4420 may_break: false, // Will get updated if/when we find a `break`.
4423 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4424 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4425 let cond_diverging = self.diverges.get();
4426 self.check_block_no_value(&body);
4428 // We may never reach the body so it diverging means nothing.
4429 self.diverges.set(cond_diverging);
4433 // No way to know whether it's diverging because
4434 // of a `break` or an outer `break` or `return`.
4435 self.diverges.set(Diverges::Maybe);
4440 ExprKind::Loop(ref body, _, source) => {
4441 let coerce = match source {
4442 // you can only use break with a value from a normal `loop { }`
4443 hir::LoopSource::Loop => {
4444 let coerce_to = expected.coercion_target_type(self, body.span);
4445 Some(CoerceMany::new(coerce_to))
4448 hir::LoopSource::WhileLet |
4449 hir::LoopSource::ForLoop => {
4454 let ctxt = BreakableCtxt {
4456 may_break: false, // Will get updated if/when we find a `break`.
4459 let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
4460 self.check_block_no_value(&body);
4464 // No way to know whether it's diverging because
4465 // of a `break` or an outer `break` or `return`.
4466 self.diverges.set(Diverges::Maybe);
4469 // If we permit break with a value, then result type is
4470 // the LUB of the breaks (possibly ! if none); else, it
4471 // is nil. This makes sense because infinite loops
4472 // (which would have type !) are only possible iff we
4473 // permit break with a value [1].
4474 if ctxt.coerce.is_none() && !ctxt.may_break {
4476 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4478 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4480 ExprKind::Match(ref discrim, ref arms, match_src) => {
4481 self.check_match(expr, &discrim, arms, expected, match_src)
4483 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4484 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4486 ExprKind::Block(ref body, _) => {
4487 self.check_block_with_expected(&body, expected)
4489 ExprKind::Call(ref callee, ref args) => {
4490 self.check_call(expr, &callee, args, expected)
4492 ExprKind::MethodCall(ref segment, span, ref args) => {
4493 self.check_method_call(expr, segment, span, args, expected, needs)
4495 ExprKind::Cast(ref e, ref t) => {
4496 // Find the type of `e`. Supply hints based on the type we are casting to,
4498 let t_cast = self.to_ty_saving_user_provided_ty(t);
4499 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4500 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4501 let t_cast = self.resolve_type_vars_if_possible(&t_cast);
4503 // Eagerly check for some obvious errors.
4504 if t_expr.references_error() || t_cast.references_error() {
4507 // Defer other checks until we're done type checking.
4508 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4509 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4511 deferred_cast_checks.push(cast_check);
4514 Err(ErrorReported) => {
4520 ExprKind::Type(ref e, ref t) => {
4521 let ty = self.to_ty_saving_user_provided_ty(&t);
4522 self.check_expr_eq_type(&e, ty);
4525 ExprKind::Array(ref args) => {
4526 let uty = expected.to_option(self).and_then(|uty| {
4528 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4533 let element_ty = if !args.is_empty() {
4534 let coerce_to = uty.unwrap_or_else(
4535 || self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span)));
4536 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4537 assert_eq!(self.diverges.get(), Diverges::Maybe);
4539 let e_ty = self.check_expr_with_hint(e, coerce_to);
4540 let cause = self.misc(e.span);
4541 coerce.coerce(self, &cause, e, e_ty);
4543 coerce.complete(self)
4545 self.next_ty_var(TypeVariableOrigin::TypeInference(expr.span))
4547 tcx.mk_array(element_ty, args.len() as u64)
4549 ExprKind::Repeat(ref element, ref count) => {
4550 let count_def_id = tcx.hir().local_def_id(count.id);
4551 let param_env = ty::ParamEnv::empty();
4552 let substs = Substs::identity_for_item(tcx.global_tcx(), count_def_id);
4553 let instance = ty::Instance::resolve(
4559 let global_id = GlobalId {
4563 let count = tcx.const_eval(param_env.and(global_id));
4565 let uty = match expected {
4566 ExpectHasType(uty) => {
4568 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4575 let (element_ty, t) = match uty {
4577 self.check_expr_coercable_to_type(&element, uty);
4581 let ty = self.next_ty_var(TypeVariableOrigin::MiscVariable(element.span));
4582 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4587 if let Ok(count) = count {
4588 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4590 // For [foo, ..n] where n > 1, `foo` must have
4592 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4593 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4597 if element_ty.references_error() {
4599 } else if let Ok(count) = count {
4600 tcx.mk_ty(ty::Array(t, tcx.intern_lazy_const(ty::LazyConst::Evaluated(count))))
4605 ExprKind::Tup(ref elts) => {
4606 let flds = expected.only_has_type(self).and_then(|ty| {
4607 let ty = self.resolve_type_vars_with_obligations(ty);
4609 ty::Tuple(ref flds) => Some(&flds[..]),
4614 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4615 let t = match flds {
4616 Some(ref fs) if i < fs.len() => {
4618 self.check_expr_coercable_to_type(&e, ety);
4622 self.check_expr_with_expectation(&e, NoExpectation)
4627 let tuple = tcx.mk_tup(elt_ts_iter);
4628 if tuple.references_error() {
4631 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4635 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4636 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4638 ExprKind::Field(ref base, field) => {
4639 self.check_field(expr, needs, &base, field)
4641 ExprKind::Index(ref base, ref idx) => {
4642 let base_t = self.check_expr_with_needs(&base, needs);
4643 let idx_t = self.check_expr(&idx);
4645 if base_t.references_error() {
4647 } else if idx_t.references_error() {
4650 let base_t = self.structurally_resolved_type(base.span, base_t);
4651 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4652 Some((index_ty, element_ty)) => {
4653 // two-phase not needed because index_ty is never mutable
4654 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4659 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4660 "cannot index into a value of type `{}`",
4662 // Try to give some advice about indexing tuples.
4663 if let ty::Tuple(..) = base_t.sty {
4664 let mut needs_note = true;
4665 // If the index is an integer, we can show the actual
4666 // fixed expression:
4667 if let ExprKind::Lit(ref lit) = idx.node {
4668 if let ast::LitKind::Int(i,
4669 ast::LitIntType::Unsuffixed) = lit.node {
4670 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4671 if let Ok(snip) = snip {
4672 err.span_suggestion(
4674 "to access tuple elements, use",
4675 format!("{}.{}", snip, i),
4676 Applicability::MachineApplicable,
4683 err.help("to access tuple elements, use tuple indexing \
4684 syntax (e.g., `tuple.0`)");
4693 ExprKind::Yield(ref value) => {
4694 match self.yield_ty {
4696 self.check_expr_coercable_to_type(&value, ty);
4699 struct_span_err!(self.tcx.sess, expr.span, E0627,
4700 "yield statement outside of generator literal").emit();
4705 hir::ExprKind::Err => {
4711 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4712 // The newly resolved definition is written into `type_dependent_defs`.
4713 fn finish_resolving_struct_path(&self,
4716 node_id: ast::NodeId)
4720 QPath::Resolved(ref maybe_qself, ref path) => {
4721 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4722 let ty = AstConv::def_to_ty(self, self_ty, path, true);
4725 QPath::TypeRelative(ref qself, ref segment) => {
4726 let ty = self.to_ty(qself);
4728 let def = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4733 let (ty, def) = AstConv::associated_path_to_ty(self, node_id, path_span,
4734 ty, def, segment, true);
4736 // Write back the new resolution.
4737 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4738 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4745 // Resolve associated value path into a base type and associated constant or method definition.
4746 // The newly resolved definition is written into `type_dependent_defs`.
4747 pub fn resolve_ty_and_def_ufcs<'b>(&self,
4749 node_id: ast::NodeId,
4751 -> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4753 debug!("resolve_ty_and_def_ufcs: qpath={:?} node_id={:?} span={:?}", qpath, node_id, span);
4754 let (ty, qself, item_segment) = match *qpath {
4755 QPath::Resolved(ref opt_qself, ref path) => {
4757 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4758 &path.segments[..]);
4760 QPath::TypeRelative(ref qself, ref segment) => {
4761 (self.to_ty(qself), qself, segment)
4764 let hir_id = self.tcx.hir().node_to_hir_id(node_id);
4765 if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4766 // Return directly on cache hit. This is useful to avoid doubly reporting
4767 // errors with default match binding modes. See #44614.
4768 return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
4770 let item_name = item_segment.ident;
4771 let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
4774 let def = match error {
4775 method::MethodError::PrivateMatch(def, _) => def,
4778 if item_name.name != keywords::Invalid.name() {
4779 self.report_method_error(span,
4782 SelfSource::QPath(qself),
4790 // Write back the new resolution.
4791 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
4792 (def, Some(ty), slice::from_ref(&**item_segment))
4795 pub fn check_decl_initializer(&self,
4796 local: &'gcx hir::Local,
4797 init: &'gcx hir::Expr) -> Ty<'tcx>
4799 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4800 // for #42640 (default match binding modes).
4803 let ref_bindings = local.pat.contains_explicit_ref_binding();
4805 let local_ty = self.local_ty(init.span, local.id).revealed_ty;
4806 if let Some(m) = ref_bindings {
4807 // Somewhat subtle: if we have a `ref` binding in the pattern,
4808 // we want to avoid introducing coercions for the RHS. This is
4809 // both because it helps preserve sanity and, in the case of
4810 // ref mut, for soundness (issue #23116). In particular, in
4811 // the latter case, we need to be clear that the type of the
4812 // referent for the reference that results is *equal to* the
4813 // type of the place it is referencing, and not some
4814 // supertype thereof.
4815 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4816 self.demand_eqtype(init.span, local_ty, init_ty);
4819 self.check_expr_coercable_to_type(init, local_ty)
4823 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4824 let t = self.local_ty(local.span, local.id).decl_ty;
4825 self.write_ty(local.hir_id, t);
4827 if let Some(ref init) = local.init {
4828 let init_ty = self.check_decl_initializer(local, &init);
4829 if init_ty.references_error() {
4830 self.write_ty(local.hir_id, init_ty);
4834 self.check_pat_walk(
4837 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4840 let pat_ty = self.node_ty(local.pat.hir_id);
4841 if pat_ty.references_error() {
4842 self.write_ty(local.hir_id, pat_ty);
4846 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4847 // Don't do all the complex logic below for `DeclItem`.
4849 hir::StmtKind::Item(..) => return,
4850 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4853 self.warn_if_unreachable(stmt.id, stmt.span, "statement");
4855 // Hide the outer diverging and `has_errors` flags.
4856 let old_diverges = self.diverges.get();
4857 let old_has_errors = self.has_errors.get();
4858 self.diverges.set(Diverges::Maybe);
4859 self.has_errors.set(false);
4862 hir::StmtKind::Local(ref l) => {
4863 self.check_decl_local(&l);
4866 hir::StmtKind::Item(_) => {}
4867 hir::StmtKind::Expr(ref expr) => {
4868 // Check with expected type of `()`.
4869 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4871 hir::StmtKind::Semi(ref expr) => {
4872 self.check_expr(&expr);
4876 // Combine the diverging and `has_error` flags.
4877 self.diverges.set(self.diverges.get() | old_diverges);
4878 self.has_errors.set(self.has_errors.get() | old_has_errors);
4881 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4882 let unit = self.tcx.mk_unit();
4883 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4885 // if the block produces a `!` value, that can always be
4886 // (effectively) coerced to unit.
4888 self.demand_suptype(blk.span, unit, ty);
4892 fn check_block_with_expected(&self,
4893 blk: &'gcx hir::Block,
4894 expected: Expectation<'tcx>) -> Ty<'tcx> {
4896 let mut fcx_ps = self.ps.borrow_mut();
4897 let unsafety_state = fcx_ps.recurse(blk);
4898 replace(&mut *fcx_ps, unsafety_state)
4901 // In some cases, blocks have just one exit, but other blocks
4902 // can be targeted by multiple breaks. This can happen both
4903 // with labeled blocks as well as when we desugar
4904 // a `try { ... }` expression.
4908 // 'a: { if true { break 'a Err(()); } Ok(()) }
4910 // Here we would wind up with two coercions, one from
4911 // `Err(())` and the other from the tail expression
4912 // `Ok(())`. If the tail expression is omitted, that's a
4913 // "forced unit" -- unless the block diverges, in which
4914 // case we can ignore the tail expression (e.g., `'a: {
4915 // break 'a 22; }` would not force the type of the block
4917 let tail_expr = blk.expr.as_ref();
4918 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4919 let coerce = if blk.targeted_by_break {
4920 CoerceMany::new(coerce_to_ty)
4922 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4923 Some(e) => slice::from_ref(e),
4926 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4929 let prev_diverges = self.diverges.get();
4930 let ctxt = BreakableCtxt {
4931 coerce: Some(coerce),
4935 let (ctxt, ()) = self.with_breakable_ctxt(blk.id, ctxt, || {
4936 for s in &blk.stmts {
4940 // check the tail expression **without** holding the
4941 // `enclosing_breakables` lock below.
4942 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4944 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4945 let ctxt = enclosing_breakables.find_breakable(blk.id);
4946 let coerce = ctxt.coerce.as_mut().unwrap();
4947 if let Some(tail_expr_ty) = tail_expr_ty {
4948 let tail_expr = tail_expr.unwrap();
4949 let cause = self.cause(tail_expr.span,
4950 ObligationCauseCode::BlockTailExpression(blk.id));
4956 // Subtle: if there is no explicit tail expression,
4957 // that is typically equivalent to a tail expression
4958 // of `()` -- except if the block diverges. In that
4959 // case, there is no value supplied from the tail
4960 // expression (assuming there are no other breaks,
4961 // this implies that the type of the block will be
4964 // #41425 -- label the implicit `()` as being the
4965 // "found type" here, rather than the "expected type".
4966 if !self.diverges.get().always() {
4967 // #50009 -- Do not point at the entire fn block span, point at the return type
4968 // span, as it is the cause of the requirement, and
4969 // `consider_hint_about_removing_semicolon` will point at the last expression
4970 // if it were a relevant part of the error. This improves usability in editors
4971 // that highlight errors inline.
4972 let mut sp = blk.span;
4973 let mut fn_span = None;
4974 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.id) {
4975 let ret_sp = decl.output.span();
4976 if let Some(block_sp) = self.parent_item_span(blk.id) {
4977 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4978 // output would otherwise be incorrect and even misleading. Make sure
4979 // the span we're aiming at correspond to a `fn` body.
4980 if block_sp == blk.span {
4982 fn_span = Some(ident.span);
4986 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4987 if let Some(expected_ty) = expected.only_has_type(self) {
4988 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4990 if let Some(fn_span) = fn_span {
4991 err.span_label(fn_span, "this function's body doesn't return");
4999 // If we can break from the block, then the block's exit is always reachable
5000 // (... as long as the entry is reachable) - regardless of the tail of the block.
5001 self.diverges.set(prev_diverges);
5004 let mut ty = ctxt.coerce.unwrap().complete(self);
5006 if self.has_errors.get() || ty.references_error() {
5007 ty = self.tcx.types.err
5010 self.write_ty(blk.hir_id, ty);
5012 *self.ps.borrow_mut() = prev;
5016 fn parent_item_span(&self, id: ast::NodeId) -> Option<Span> {
5017 let node = self.tcx.hir().get(self.tcx.hir().get_parent(id));
5019 Node::Item(&hir::Item {
5020 node: hir::ItemKind::Fn(_, _, _, body_id), ..
5022 Node::ImplItem(&hir::ImplItem {
5023 node: hir::ImplItemKind::Method(_, body_id), ..
5025 let body = self.tcx.hir().body(body_id);
5026 if let ExprKind::Block(block, _) = &body.value.node {
5027 return Some(block.span);
5035 /// Given a function block's `NodeId`, return its `FnDecl` if it exists, or `None` otherwise.
5036 fn get_parent_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, ast::Ident)> {
5037 let parent = self.tcx.hir().get(self.tcx.hir().get_parent(blk_id));
5038 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
5041 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
5042 fn get_node_fn_decl(&self, node: Node) -> Option<(hir::FnDecl, ast::Ident, bool)> {
5044 Node::Item(&hir::Item {
5045 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
5046 }) => decl.clone().and_then(|decl| {
5047 // This is less than ideal, it will not suggest a return type span on any
5048 // method called `main`, regardless of whether it is actually the entry point,
5049 // but it will still present it as the reason for the expected type.
5050 Some((decl, ident, ident.name != Symbol::intern("main")))
5052 Node::TraitItem(&hir::TraitItem {
5053 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5056 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5057 Node::ImplItem(&hir::ImplItem {
5058 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5061 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5066 /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
5067 /// suggestion can be made, `None` otherwise.
5068 pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
5069 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5070 // `while` before reaching it, as block tail returns are not available in them.
5071 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5072 let parent = self.tcx.hir().get(blk_id);
5073 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5077 /// On implicit return expressions with mismatched types, provide the following suggestions:
5079 /// - Point out the method's return type as the reason for the expected type
5080 /// - Possible missing semicolon
5081 /// - Possible missing return type if the return type is the default, and not `fn main()`
5082 pub fn suggest_mismatched_types_on_tail(
5084 err: &mut DiagnosticBuilder<'tcx>,
5085 expression: &'gcx hir::Expr,
5089 blk_id: ast::NodeId,
5091 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5092 let mut pointing_at_return_type = false;
5093 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5094 pointing_at_return_type = self.suggest_missing_return_type(
5095 err, &fn_decl, expected, found, can_suggest);
5097 self.suggest_ref_or_into(err, expression, expected, found);
5098 pointing_at_return_type
5101 pub fn suggest_ref_or_into(
5103 err: &mut DiagnosticBuilder<'tcx>,
5108 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5109 err.span_suggestion(
5113 Applicability::MachineApplicable,
5115 } else if !self.check_for_cast(err, expr, found, expected) {
5116 let methods = self.get_conversion_methods(expr.span, expected, found);
5117 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5118 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5119 .filter_map(|(receiver, method)| {
5120 let method_call = format!(".{}()", method.ident);
5121 if receiver.ends_with(&method_call) {
5122 None // do not suggest code that is already there (#53348)
5124 let method_call_list = [".to_vec()", ".to_string()"];
5125 if receiver.ends_with(".clone()")
5126 && method_call_list.contains(&method_call.as_str()) {
5127 let max_len = receiver.rfind(".").unwrap();
5128 Some(format!("{}{}", &receiver[..max_len], method_call))
5131 Some(format!("{}{}", receiver, method_call))
5135 if suggestions.peek().is_some() {
5136 err.span_suggestions(
5138 "try using a conversion method",
5140 Applicability::MaybeIncorrect,
5147 /// A common error is to forget to add a semicolon at the end of a block:
5151 /// bar_that_returns_u32()
5155 /// This routine checks if the return expression in a block would make sense on its own as a
5156 /// statement and the return type has been left as default or has been specified as `()`. If so,
5157 /// it suggests adding a semicolon.
5158 fn suggest_missing_semicolon(&self,
5159 err: &mut DiagnosticBuilder<'tcx>,
5160 expression: &'gcx hir::Expr,
5163 if expected.is_unit() {
5164 // `BlockTailExpression` only relevant if the tail expr would be
5165 // useful on its own.
5166 match expression.node {
5167 ExprKind::Call(..) |
5168 ExprKind::MethodCall(..) |
5170 ExprKind::While(..) |
5171 ExprKind::Loop(..) |
5172 ExprKind::Match(..) |
5173 ExprKind::Block(..) => {
5174 let sp = self.tcx.sess.source_map().next_point(cause_span);
5175 err.span_suggestion(
5177 "try adding a semicolon",
5179 Applicability::MachineApplicable);
5186 /// A possible error is to forget to add a return type that is needed:
5190 /// bar_that_returns_u32()
5194 /// This routine checks if the return type is left as default, the method is not part of an
5195 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5197 fn suggest_missing_return_type(
5199 err: &mut DiagnosticBuilder<'tcx>,
5200 fn_decl: &hir::FnDecl,
5205 // Only suggest changing the return type for methods that
5206 // haven't set a return type at all (and aren't `fn main()` or an impl).
5207 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5208 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5209 err.span_suggestion(
5211 "try adding a return type",
5212 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5213 Applicability::MachineApplicable);
5216 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5217 err.span_label(span, "possibly return type missing here?");
5220 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5221 // `fn main()` must return `()`, do not suggest changing return type
5222 err.span_label(span, "expected `()` because of default return type");
5225 // expectation was caused by something else, not the default return
5226 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5227 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5228 // Only point to return type if the expected type is the return type, as if they
5229 // are not, the expectation must have been caused by something else.
5230 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5232 let ty = AstConv::ast_ty_to_ty(self, ty);
5233 debug!("suggest_missing_return_type: return type sty {:?}", ty.sty);
5234 debug!("suggest_missing_return_type: expected type sty {:?}", ty.sty);
5235 if ty.sty == expected.sty {
5236 err.span_label(sp, format!("expected `{}` because of return type",
5245 /// A common error is to add an extra semicolon:
5248 /// fn foo() -> usize {
5253 /// This routine checks if the final statement in a block is an
5254 /// expression with an explicit semicolon whose type is compatible
5255 /// with `expected_ty`. If so, it suggests removing the semicolon.
5256 fn consider_hint_about_removing_semicolon(
5258 blk: &'gcx hir::Block,
5259 expected_ty: Ty<'tcx>,
5260 err: &mut DiagnosticBuilder,
5262 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5263 err.span_suggestion(
5265 "consider removing this semicolon",
5267 Applicability::MachineApplicable,
5272 fn could_remove_semicolon(
5274 blk: &'gcx hir::Block,
5275 expected_ty: Ty<'tcx>,
5277 // Be helpful when the user wrote `{... expr;}` and
5278 // taking the `;` off is enough to fix the error.
5279 let last_stmt = match blk.stmts.last() {
5281 None => return None,
5283 let last_expr = match last_stmt.node {
5284 hir::StmtKind::Semi(ref e) => e,
5287 let last_expr_ty = self.node_ty(last_expr.hir_id);
5288 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5291 let original_span = original_sp(last_stmt.span, blk.span);
5292 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5295 // Instantiates the given path, which must refer to an item with the given
5296 // number of type parameters and type.
5297 pub fn instantiate_value_path(&self,
5298 segments: &[hir::PathSegment],
5299 self_ty: Option<Ty<'tcx>>,
5302 node_id: ast::NodeId)
5303 -> (Ty<'tcx>, Def) {
5305 "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
5314 let path_segs = AstConv::def_ids_for_path_segments(self, segments, self_ty, def);
5316 let mut user_self_ty = None;
5317 let mut is_alias_variant_ctor = false;
5319 Def::VariantCtor(_, _) => {
5320 if let Some(self_ty) = self_ty {
5321 let adt_def = self_ty.ty_adt_def().unwrap();
5322 user_self_ty = Some(UserSelfTy {
5323 impl_def_id: adt_def.did,
5326 is_alias_variant_ctor = true;
5329 Def::Method(def_id) |
5330 Def::AssociatedConst(def_id) => {
5331 let container = tcx.associated_item(def_id).container;
5332 debug!("instantiate_value_path: def={:?} container={:?}", def, container);
5334 ty::TraitContainer(trait_did) => {
5335 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5337 ty::ImplContainer(impl_def_id) => {
5338 if segments.len() == 1 {
5339 // `<T>::assoc` will end up here, and so
5340 // can `T::assoc`. It this came from an
5341 // inherent impl, we need to record the
5342 // `T` for posterity (see `UserSelfTy` for
5344 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5345 user_self_ty = Some(UserSelfTy {
5356 // Now that we have categorized what space the parameters for each
5357 // segment belong to, let's sort out the parameters that the user
5358 // provided (if any) into their appropriate spaces. We'll also report
5359 // errors if type parameters are provided in an inappropriate place.
5361 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5362 let generics_has_err = AstConv::prohibit_generics(
5363 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5364 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5370 if generics_has_err {
5371 // Don't try to infer type parameters when prohibited generic arguments were given.
5372 user_self_ty = None;
5376 Def::Local(nid) | Def::Upvar(nid, ..) => {
5377 let ty = self.local_ty(span, nid).decl_ty;
5378 let ty = self.normalize_associated_types_in(span, &ty);
5379 self.write_ty(tcx.hir().node_to_hir_id(node_id), ty);
5385 // Now we have to compare the types that the user *actually*
5386 // provided against the types that were *expected*. If the user
5387 // did not provide any types, then we want to substitute inference
5388 // variables. If the user provided some types, we may still need
5389 // to add defaults. If the user provided *too many* types, that's
5392 let mut infer_args_for_err = FxHashSet::default();
5393 for &PathSeg(def_id, index) in &path_segs {
5394 let seg = &segments[index];
5395 let generics = tcx.generics_of(def_id);
5396 // Argument-position `impl Trait` is treated as a normal generic
5397 // parameter internally, but we don't allow users to specify the
5398 // parameter's value explicitly, so we have to do some error-
5400 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5405 false, // `is_method_call`
5407 if suppress_errors {
5408 infer_args_for_err.insert(index);
5409 self.set_tainted_by_errors(); // See issue #53251.
5413 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5414 tcx.generics_of(*def_id).has_self
5415 }).unwrap_or(false);
5417 let mut new_def = def;
5418 let (def_id, ty) = match def {
5419 Def::SelfCtor(impl_def_id) => {
5420 let ty = self.impl_self_ty(span, impl_def_id).ty;
5421 let adt_def = ty.ty_adt_def();
5424 Some(adt_def) if adt_def.has_ctor() => {
5425 let variant = adt_def.non_enum_variant();
5426 new_def = Def::StructCtor(variant.did, variant.ctor_kind);
5427 (variant.did, tcx.type_of(variant.did))
5430 let mut err = tcx.sess.struct_span_err(span,
5431 "the `Self` constructor can only be used with tuple or unit structs");
5432 if let Some(adt_def) = adt_def {
5433 match adt_def.adt_kind() {
5435 err.help("did you mean to use one of the enum's variants?");
5439 err.span_suggestion(
5441 "use curly brackets",
5442 String::from("Self { /* fields */ }"),
5443 Applicability::HasPlaceholders,
5450 (impl_def_id, tcx.types.err)
5455 let def_id = def.def_id();
5457 // The things we are substituting into the type should not contain
5458 // escaping late-bound regions, and nor should the base type scheme.
5459 let ty = tcx.type_of(def_id);
5464 let substs = AstConv::create_substs_for_generic_args(
5470 // Provide the generic args, and whether types should be inferred.
5472 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5475 // If we've encountered an `impl Trait`-related error, we're just
5476 // going to infer the arguments for better error messages.
5477 if !infer_args_for_err.contains(&index) {
5478 // Check whether the user has provided generic arguments.
5479 if let Some(ref data) = segments[index].args {
5480 return (Some(data), segments[index].infer_types);
5483 return (None, segments[index].infer_types);
5488 // Provide substitutions for parameters for which (valid) arguments have been provided.
5490 match (¶m.kind, arg) {
5491 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5492 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5494 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5495 self.to_ty(ty).into()
5497 _ => unreachable!(),
5500 // Provide substitutions for parameters for which arguments are inferred.
5501 |substs, param, infer_types| {
5503 GenericParamDefKind::Lifetime => {
5504 self.re_infer(span, Some(param)).unwrap().into()
5506 GenericParamDefKind::Type { has_default, .. } => {
5507 if !infer_types && has_default {
5508 // If we have a default, then we it doesn't matter that we're not
5509 // inferring the type arguments: we provide the default where any
5511 let default = tcx.type_of(param.def_id);
5514 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5517 // If no type arguments were provided, we have to infer them.
5518 // This case also occurs as a result of some malformed input, e.g.
5519 // a lifetime argument being given instead of a type parameter.
5520 // Using inference instead of `Error` gives better error messages.
5521 self.var_for_def(span, param)
5527 assert!(!substs.has_escaping_bound_vars());
5528 assert!(!ty.has_escaping_bound_vars());
5530 // First, store the "user substs" for later.
5531 let hir_id = tcx.hir().node_to_hir_id(node_id);
5532 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5534 // Add all the obligations that are required, substituting and
5535 // normalized appropriately.
5536 let bounds = self.instantiate_bounds(span, def_id, &substs);
5537 self.add_obligations_for_parameters(
5538 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5541 // Substitute the values for the type parameters into the type of
5542 // the referenced item.
5543 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5545 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5546 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5547 // is inherent, there is no `Self` parameter; instead, the impl needs
5548 // type parameters, which we can infer by unifying the provided `Self`
5549 // with the substituted impl type.
5550 // This also occurs for an enum variant on a type alias.
5551 let ty = tcx.type_of(impl_def_id);
5553 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5554 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5555 Ok(ok) => self.register_infer_ok_obligations(ok),
5558 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5565 self.check_rustc_args_require_const(def_id, node_id, span);
5567 debug!("instantiate_value_path: type of {:?} is {:?}",
5570 self.write_substs(hir_id, substs);
5572 (ty_substituted, new_def)
5575 fn check_rustc_args_require_const(&self,
5577 node_id: ast::NodeId,
5579 // We're only interested in functions tagged with
5580 // #[rustc_args_required_const], so ignore anything that's not.
5581 if !self.tcx.has_attr(def_id, "rustc_args_required_const") {
5585 // If our calling expression is indeed the function itself, we're good!
5586 // If not, generate an error that this can only be called directly.
5587 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
5588 if let ExprKind::Call(ref callee, ..) = expr.node {
5589 if callee.id == node_id {
5595 self.tcx.sess.span_err(span, "this function can only be invoked \
5596 directly, not through a function pointer");
5599 // Resolves `typ` by a single level if `typ` is a type variable.
5600 // If no resolution is possible, then an error is reported.
5601 // Numeric inference variables may be left unresolved.
5602 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5603 let ty = self.resolve_type_vars_with_obligations(ty);
5604 if !ty.is_ty_var() {
5607 if !self.is_tainted_by_errors() {
5608 self.need_type_info_err((**self).body_id, sp, ty)
5609 .note("type must be known at this point")
5612 self.demand_suptype(sp, self.tcx.types.err, ty);
5617 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
5618 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5619 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5622 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5623 index = enclosing_breakables.stack.len();
5624 enclosing_breakables.by_id.insert(id, index);
5625 enclosing_breakables.stack.push(ctxt);
5629 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5630 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5631 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5632 enclosing_breakables.stack.pop().expect("missing breakable context")
5637 /// Instantiate a QueryResponse in a probe context, without a
5638 /// good ObligationCause.
5639 fn probe_instantiate_query_response(
5642 original_values: &OriginalQueryValues<'tcx>,
5643 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5644 ) -> InferResult<'tcx, Ty<'tcx>>
5646 self.instantiate_query_response_and_region_obligations(
5647 &traits::ObligationCause::misc(span, self.body_id),
5653 /// Returns whether an expression is contained inside the LHS of an assignment expression.
5654 fn expr_in_place(&self, mut expr_id: ast::NodeId) -> bool {
5655 let mut contained_in_place = false;
5657 while let hir::Node::Expr(parent_expr) =
5658 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5660 match &parent_expr.node {
5661 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5662 if lhs.id == expr_id {
5663 contained_in_place = true;
5669 expr_id = parent_expr.id;
5676 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5677 generics: &ty::Generics,
5679 let own_counts = generics.own_counts();
5680 debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
5682 if own_counts.types == 0 {
5685 // Make a vector of booleans initially false, set to true when used.
5686 let mut types_used = vec![false; own_counts.types];
5688 for leaf_ty in ty.walk() {
5689 if let ty::Param(ty::ParamTy { idx, .. }) = leaf_ty.sty {
5690 debug!("Found use of ty param num {}", idx);
5691 types_used[idx as usize - own_counts.lifetimes] = true;
5692 } else if let ty::Error = leaf_ty.sty {
5693 // If there is already another error, do not emit
5694 // an error for not using a type Parameter.
5695 assert!(tcx.sess.err_count() > 0);
5700 let types = generics.params.iter().filter(|param| match param.kind {
5701 ty::GenericParamDefKind::Type { .. } => true,
5704 for (&used, param) in types_used.iter().zip(types) {
5706 let id = tcx.hir().as_local_node_id(param.def_id).unwrap();
5707 let span = tcx.hir().span(id);
5708 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5709 .span_label(span, "unused type parameter")
5715 fn fatally_break_rust(sess: &Session) {
5716 let handler = sess.diagnostic();
5717 handler.span_bug_no_panic(
5719 "It looks like you're trying to break rust; would you like some ICE?",
5721 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5722 handler.note_without_error(
5723 "we would appreciate a joke overview: \
5724 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5726 handler.note_without_error(&format!("rustc {} running on {}",
5727 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5728 ::session::config::host_triple(),
5732 fn potentially_plural_count(count: usize, word: &str) -> String {
5733 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })