1 // ignore-tidy-filelength
7 Within the check phase of type check, we check each item one at a time
8 (bodies of function expressions are checked as part of the containing
9 function). Inference is used to supply types wherever they are unknown.
11 By far the most complex case is checking the body of a function. This
12 can be broken down into several distinct phases:
14 - gather: creates type variables to represent the type of each local
15 variable and pattern binding.
17 - main: the main pass does the lion's share of the work: it
18 determines the types of all expressions, resolves
19 methods, checks for most invalid conditions, and so forth. In
20 some cases, where a type is unknown, it may create a type or region
21 variable and use that as the type of an expression.
23 In the process of checking, various constraints will be placed on
24 these type variables through the subtyping relationships requested
25 through the `demand` module. The `infer` module is in charge
26 of resolving those constraints.
28 - regionck: after main is complete, the regionck pass goes over all
29 types looking for regions and making sure that they did not escape
30 into places they are not in scope. This may also influence the
31 final assignments of the various region variables if there is some
34 - vtable: find and records the impls to use for each trait bound that
35 appears on a type parameter.
37 - writeback: writes the final types within a function body, replacing
38 type variables with their final inferred types. These final types
39 are written into the `tcx.node_types` table, which should *never* contain
40 any reference to a type variable.
44 While type checking a function, the intermediate types for the
45 expressions, blocks, and so forth contained within the function are
46 stored in `fcx.node_types` and `fcx.node_substs`. These types
47 may contain unresolved type variables. After type checking is
48 complete, the functions in the writeback module are used to take the
49 types from this table, resolve them, and then write them into their
50 permanent home in the type context `tcx`.
52 This means that during inferencing you should use `fcx.write_ty()`
53 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
54 nodes within the function.
56 The types of top-level items, which never contain unbound type
57 variables, are stored directly into the `tcx` tables.
59 N.B., a type variable is not the same thing as a type parameter. A
60 type variable is rather an "instance" of a type parameter: that is,
61 given a generic function `fn foo<T>(t: T)`: while checking the
62 function `foo`, the type `ty_param(0)` refers to the type `T`, which
63 is treated in abstract. When `foo()` is called, however, `T` will be
64 substituted for a fresh type variable `N`. This variable will
65 eventually be resolved to some concrete type (which might itself be
84 mod generator_interior;
88 use crate::astconv::{AstConv, PathSeg};
89 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
90 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
91 use rustc::hir::def::{CtorOf, CtorKind, Res, DefKind};
92 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
93 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
94 use rustc::hir::itemlikevisit::ItemLikeVisitor;
95 use crate::middle::lang_items;
96 use crate::namespace::Namespace;
97 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
98 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
99 use rustc_data_structures::indexed_vec::Idx;
100 use rustc_target::spec::abi::Abi;
101 use rustc::infer::opaque_types::OpaqueTypeDecl;
102 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
103 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
104 use rustc::middle::region;
105 use rustc::mir::interpret::{ConstValue, GlobalId};
106 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
108 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind, Visibility,
109 ToPolyTraitRef, ToPredicate, RegionKind, UserType
111 use rustc::ty::adjustment::{
112 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
114 use rustc::ty::fold::TypeFoldable;
115 use rustc::ty::query::Providers;
116 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
117 use rustc::ty::util::{Representability, IntTypeExt, Discr};
118 use rustc::ty::layout::VariantIdx;
119 use syntax_pos::{self, BytePos, Span, MultiSpan};
120 use syntax_pos::hygiene::CompilerDesugaringKind;
123 use syntax::feature_gate::{GateIssue, emit_feature_err};
125 use syntax::source_map::{DUMMY_SP, original_sp};
126 use syntax::symbol::{Symbol, LocalInternedString, kw, sym};
127 use syntax::util::lev_distance::find_best_match_for_name;
129 use std::cell::{Cell, RefCell, Ref, RefMut};
130 use std::collections::hash_map::Entry;
132 use std::fmt::Display;
134 use std::mem::replace;
135 use std::ops::{self, Deref};
138 use crate::require_c_abi_if_c_variadic;
139 use crate::session::Session;
140 use crate::session::config::EntryFnType;
141 use crate::TypeAndSubsts;
143 use crate::util::captures::Captures;
144 use crate::util::common::{ErrorReported, indenter};
145 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap};
147 pub use self::Expectation::*;
148 use self::autoderef::Autoderef;
149 use self::callee::DeferredCallResolution;
150 use self::coercion::{CoerceMany, DynamicCoerceMany};
151 pub use self::compare_method::{compare_impl_method, compare_const_impl};
152 use self::method::{MethodCallee, SelfSource};
153 use self::TupleArgumentsFlag::*;
155 /// The type of a local binding, including the revealed type for anon types.
156 #[derive(Copy, Clone)]
157 pub struct LocalTy<'tcx> {
159 revealed_ty: Ty<'tcx>
162 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
163 #[derive(Copy, Clone)]
164 struct MaybeInProgressTables<'a, 'tcx: 'a> {
165 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
168 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
169 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
178 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
179 match self.maybe_tables {
180 Some(tables) => tables.borrow_mut(),
182 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
188 /// Closures defined within the function. For example:
191 /// bar(move|| { ... })
194 /// Here, the function `foo()` and the closure passed to
195 /// `bar()` will each have their own `FnCtxt`, but they will
196 /// share the inherited fields.
197 pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
198 infcx: InferCtxt<'a, 'gcx, 'tcx>,
200 tables: MaybeInProgressTables<'a, 'tcx>,
202 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
204 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
206 // Some additional `Sized` obligations badly affect type inference.
207 // These obligations are added in a later stage of typeck.
208 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
210 // When we process a call like `c()` where `c` is a closure type,
211 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
212 // `FnOnce` closure. In that case, we defer full resolution of the
213 // call until upvar inference can kick in and make the
214 // decision. We keep these deferred resolutions grouped by the
215 // def-id of the closure, so that once we decide, we can easily go
216 // back and process them.
217 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
219 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
221 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>)>>,
223 // Opaque types found in explicit return types and their
224 // associated fresh inference variable. Writeback resolves these
225 // variables to get the concrete type, which can be used to
226 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
227 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
229 /// Each type parameter has an implicit region bound that
230 /// indicates it must outlive at least the function body (the user
231 /// may specify stronger requirements). This field indicates the
232 /// region of the callee. If it is `None`, then the parameter
233 /// environment is for an item or something where the "callee" is
235 implicit_region_bound: Option<ty::Region<'tcx>>,
237 body_id: Option<hir::BodyId>,
240 impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
241 type Target = InferCtxt<'a, 'gcx, 'tcx>;
242 fn deref(&self) -> &Self::Target {
247 /// When type-checking an expression, we propagate downward
248 /// whatever type hint we are able in the form of an `Expectation`.
249 #[derive(Copy, Clone, Debug)]
250 pub enum Expectation<'tcx> {
251 /// We know nothing about what type this expression should have.
254 /// This expression should have the type given (or some subtype).
255 ExpectHasType(Ty<'tcx>),
257 /// This expression will be cast to the `Ty`.
258 ExpectCastableToType(Ty<'tcx>),
260 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
261 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
262 ExpectRvalueLikeUnsized(Ty<'tcx>),
265 impl<'a, 'gcx, 'tcx> Expectation<'tcx> {
266 // Disregard "castable to" expectations because they
267 // can lead us astray. Consider for example `if cond
268 // {22} else {c} as u8` -- if we propagate the
269 // "castable to u8" constraint to 22, it will pick the
270 // type 22u8, which is overly constrained (c might not
271 // be a u8). In effect, the problem is that the
272 // "castable to" expectation is not the tightest thing
273 // we can say, so we want to drop it in this case.
274 // The tightest thing we can say is "must unify with
275 // else branch". Note that in the case of a "has type"
276 // constraint, this limitation does not hold.
278 // If the expected type is just a type variable, then don't use
279 // an expected type. Otherwise, we might write parts of the type
280 // when checking the 'then' block which are incompatible with the
282 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
284 ExpectHasType(ety) => {
285 let ety = fcx.shallow_resolve(ety);
286 if !ety.is_ty_var() {
292 ExpectRvalueLikeUnsized(ety) => {
293 ExpectRvalueLikeUnsized(ety)
299 /// Provides an expectation for an rvalue expression given an *optional*
300 /// hint, which is not required for type safety (the resulting type might
301 /// be checked higher up, as is the case with `&expr` and `box expr`), but
302 /// is useful in determining the concrete type.
304 /// The primary use case is where the expected type is a fat pointer,
305 /// like `&[isize]`. For example, consider the following statement:
307 /// let x: &[isize] = &[1, 2, 3];
309 /// In this case, the expected type for the `&[1, 2, 3]` expression is
310 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
311 /// expectation `ExpectHasType([isize])`, that would be too strong --
312 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
313 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
314 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
315 /// which still is useful, because it informs integer literals and the like.
316 /// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
317 /// for examples of where this comes up,.
318 fn rvalue_hint(fcx: &FnCtxt<'a, 'gcx, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
319 match fcx.tcx.struct_tail(ty).sty {
320 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
321 ExpectRvalueLikeUnsized(ty)
323 _ => ExpectHasType(ty)
327 // Resolves `expected` by a single level if it is a variable. If
328 // there is no expected type or resolution is not possible (e.g.,
329 // no constraints yet present), just returns `None`.
330 fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Expectation<'tcx> {
332 NoExpectation => NoExpectation,
333 ExpectCastableToType(t) => {
334 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
336 ExpectHasType(t) => {
337 ExpectHasType(fcx.resolve_vars_if_possible(&t))
339 ExpectRvalueLikeUnsized(t) => {
340 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
345 fn to_option(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
346 match self.resolve(fcx) {
347 NoExpectation => None,
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 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
365 /// Like `only_has_type`, but instead of returning `None` if no
366 /// hard constraint exists, creates a fresh type variable.
367 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>, span: Span) -> Ty<'tcx> {
368 self.only_has_type(fcx)
370 fcx.next_ty_var(TypeVariableOrigin {
371 kind: TypeVariableOriginKind::MiscVariable,
378 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
385 fn maybe_mut_place(m: hir::Mutability) -> Self {
387 hir::MutMutable => Needs::MutPlace,
388 hir::MutImmutable => Needs::None,
393 #[derive(Copy, Clone)]
394 pub struct UnsafetyState {
396 pub unsafety: hir::Unsafety,
397 pub unsafe_push_count: u32,
402 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
403 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
406 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
407 match self.unsafety {
408 // If this unsafe, then if the outer function was already marked as
409 // unsafe we shouldn't attribute the unsafe'ness to the block. This
410 // way the block can be warned about instead of ignoring this
411 // extraneous block (functions are never warned about).
412 hir::Unsafety::Unsafe if self.from_fn => *self,
415 let (unsafety, def, count) = match blk.rules {
416 hir::PushUnsafeBlock(..) =>
417 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
418 hir::PopUnsafeBlock(..) =>
419 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
420 hir::UnsafeBlock(..) =>
421 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
423 (unsafety, self.def, self.unsafe_push_count),
427 unsafe_push_count: count,
434 #[derive(Debug, Copy, Clone)]
440 /// Tracks whether executing a node may exit normally (versus
441 /// return/break/panic, which "diverge", leaving dead code in their
442 /// wake). Tracked semi-automatically (through type variables marked
443 /// as diverging), with some manual adjustments for control-flow
444 /// primitives (approximating a CFG).
445 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
447 /// Potentially unknown, some cases converge,
448 /// others require a CFG to determine them.
451 /// Definitely known to diverge and therefore
452 /// not reach the next sibling or its parent.
455 /// Same as `Always` but with a reachability
456 /// warning already emitted.
460 // Convenience impls for combinig `Diverges`.
462 impl ops::BitAnd for Diverges {
464 fn bitand(self, other: Self) -> Self {
465 cmp::min(self, other)
469 impl ops::BitOr for Diverges {
471 fn bitor(self, other: Self) -> Self {
472 cmp::max(self, other)
476 impl ops::BitAndAssign for Diverges {
477 fn bitand_assign(&mut self, other: Self) {
478 *self = *self & other;
482 impl ops::BitOrAssign for Diverges {
483 fn bitor_assign(&mut self, other: Self) {
484 *self = *self | other;
489 fn always(self) -> bool {
490 self >= Diverges::Always
494 pub struct BreakableCtxt<'gcx: 'tcx, 'tcx> {
497 // this is `null` for loops where break with a value is illegal,
498 // such as `while`, `for`, and `while let`
499 coerce: Option<DynamicCoerceMany<'gcx, 'tcx>>,
502 pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
503 stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
504 by_id: HirIdMap<usize>,
507 impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
508 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
509 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
510 bug!("could not find enclosing breakable with id {}", target_id);
516 pub struct FnCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
519 /// The parameter environment used for proving trait obligations
520 /// in this function. This can change when we descend into
521 /// closures (as they bring new things into scope), hence it is
522 /// not part of `Inherited` (as of the time of this writing,
523 /// closures do not yet change the environment, but they will
525 param_env: ty::ParamEnv<'tcx>,
527 /// Number of errors that had been reported when we started
528 /// checking this function. On exit, if we find that *more* errors
529 /// have been reported, we will skip regionck and other work that
530 /// expects the types within the function to be consistent.
531 err_count_on_creation: usize,
533 ret_coercion: Option<RefCell<DynamicCoerceMany<'gcx, 'tcx>>>,
534 ret_coercion_span: RefCell<Option<Span>>,
536 yield_ty: Option<Ty<'tcx>>,
538 ps: RefCell<UnsafetyState>,
540 /// Whether the last checked node generates a divergence (e.g.,
541 /// `return` will set this to `Always`). In general, when entering
542 /// an expression or other node in the tree, the initial value
543 /// indicates whether prior parts of the containing expression may
544 /// have diverged. It is then typically set to `Maybe` (and the
545 /// old value remembered) for processing the subparts of the
546 /// current expression. As each subpart is processed, they may set
547 /// the flag to `Always`, etc. Finally, at the end, we take the
548 /// result and "union" it with the original value, so that when we
549 /// return the flag indicates if any subpart of the parent
550 /// expression (up to and including this part) has diverged. So,
551 /// if you read it after evaluating a subexpression `X`, the value
552 /// you get indicates whether any subexpression that was
553 /// evaluating up to and including `X` diverged.
555 /// We currently use this flag only for diagnostic purposes:
557 /// - To warn about unreachable code: if, after processing a
558 /// sub-expression but before we have applied the effects of the
559 /// current node, we see that the flag is set to `Always`, we
560 /// can issue a warning. This corresponds to something like
561 /// `foo(return)`; we warn on the `foo()` expression. (We then
562 /// update the flag to `WarnedAlways` to suppress duplicate
563 /// reports.) Similarly, if we traverse to a fresh statement (or
564 /// tail expression) from a `Always` setting, we will issue a
565 /// warning. This corresponds to something like `{return;
566 /// foo();}` or `{return; 22}`, where we would warn on the
569 /// An expression represents dead code if, after checking it,
570 /// the diverges flag is set to something other than `Maybe`.
571 diverges: Cell<Diverges>,
573 /// Whether any child nodes have any type errors.
574 has_errors: Cell<bool>,
576 enclosing_breakables: RefCell<EnclosingBreakables<'gcx, 'tcx>>,
578 inh: &'a Inherited<'a, 'gcx, 'tcx>,
581 impl<'a, 'gcx, 'tcx> Deref for FnCtxt<'a, 'gcx, 'tcx> {
582 type Target = Inherited<'a, 'gcx, 'tcx>;
583 fn deref(&self) -> &Self::Target {
588 /// Helper type of a temporary returned by `Inherited::build(...)`.
589 /// Necessary because we can't write the following bound:
590 /// `F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(Inherited<'b, 'gcx, 'tcx>)`.
591 pub struct InheritedBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
592 infcx: infer::InferCtxtBuilder<'a, 'gcx, 'tcx>,
596 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
597 pub fn build(tcx: TyCtxt<'a, 'gcx, 'gcx>, def_id: DefId)
598 -> InheritedBuilder<'a, 'gcx, 'tcx> {
599 let hir_id_root = if def_id.is_local() {
600 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
601 DefId::local(hir_id.owner)
607 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
613 impl<'a, 'gcx, 'tcx> InheritedBuilder<'a, 'gcx, 'tcx> {
614 fn enter<F, R>(&'tcx mut self, f: F) -> R
615 where F: for<'b> FnOnce(Inherited<'b, 'gcx, 'tcx>) -> R
617 let def_id = self.def_id;
618 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
622 impl<'a, 'gcx, 'tcx> Inherited<'a, 'gcx, 'tcx> {
623 fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, def_id: DefId) -> Self {
625 let item_id = tcx.hir().as_local_hir_id(def_id);
626 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by_by_hir_id(id));
627 let implicit_region_bound = body_id.map(|body_id| {
628 let body = tcx.hir().body(body_id);
629 tcx.mk_region(ty::ReScope(region::Scope {
630 id: body.value.hir_id.local_id,
631 data: region::ScopeData::CallSite
636 tables: MaybeInProgressTables {
637 maybe_tables: infcx.in_progress_tables,
640 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
641 locals: RefCell::new(Default::default()),
642 deferred_sized_obligations: RefCell::new(Vec::new()),
643 deferred_call_resolutions: RefCell::new(Default::default()),
644 deferred_cast_checks: RefCell::new(Vec::new()),
645 deferred_generator_interiors: RefCell::new(Vec::new()),
646 opaque_types: RefCell::new(Default::default()),
647 implicit_region_bound,
652 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
653 debug!("register_predicate({:?})", obligation);
654 if obligation.has_escaping_bound_vars() {
655 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
660 .register_predicate_obligation(self, obligation);
663 fn register_predicates<I>(&self, obligations: I)
664 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
666 for obligation in obligations {
667 self.register_predicate(obligation);
671 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
672 self.register_predicates(infer_ok.obligations);
676 fn normalize_associated_types_in<T>(&self,
679 param_env: ty::ParamEnv<'tcx>,
681 where T : TypeFoldable<'tcx>
683 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
684 self.register_infer_ok_obligations(ok)
688 struct CheckItemTypesVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
690 impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
691 fn visit_item(&mut self, i: &'tcx hir::Item) {
692 check_item_type(self.tcx, i);
694 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
695 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
698 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
699 tcx.sess.track_errors(|| {
700 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
701 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
705 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
706 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
709 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) {
710 debug_assert!(crate_num == LOCAL_CRATE);
711 tcx.par_body_owners(|body_owner_def_id| {
712 tcx.ensure().typeck_tables_of(body_owner_def_id);
716 fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
717 wfcheck::check_item_well_formed(tcx, def_id);
720 fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
721 wfcheck::check_trait_item(tcx, def_id);
724 fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
725 wfcheck::check_impl_item(tcx, def_id);
728 pub fn provide(providers: &mut Providers<'_>) {
729 method::provide(providers);
730 *providers = Providers {
736 check_item_well_formed,
737 check_trait_item_well_formed,
738 check_impl_item_well_formed,
739 check_mod_item_types,
744 fn adt_destructor<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
746 -> Option<ty::Destructor> {
747 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
750 /// If this `DefId` is a "primary tables entry", returns `Some((body_id, decl))`
751 /// with information about it's body-id and fn-decl (if any). Otherwise,
754 /// If this function returns "some", then `typeck_tables(def_id)` will
755 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
756 /// may not succeed. In some cases where this function returns `None`
757 /// (notably closures), `typeck_tables(def_id)` would wind up
758 /// redirecting to the owning function.
759 fn primary_body_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
761 -> Option<(hir::BodyId, Option<&'tcx hir::FnDecl>)>
763 match tcx.hir().get_by_hir_id(id) {
764 Node::Item(item) => {
766 hir::ItemKind::Const(_, body) |
767 hir::ItemKind::Static(_, _, body) =>
769 hir::ItemKind::Fn(ref decl, .., body) =>
770 Some((body, Some(decl))),
775 Node::TraitItem(item) => {
777 hir::TraitItemKind::Const(_, Some(body)) =>
779 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
780 Some((body, Some(&sig.decl))),
785 Node::ImplItem(item) => {
787 hir::ImplItemKind::Const(_, body) =>
789 hir::ImplItemKind::Method(ref sig, body) =>
790 Some((body, Some(&sig.decl))),
795 Node::AnonConst(constant) => Some((constant.body, None)),
800 fn has_typeck_tables<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
803 // Closures' tables come from their outermost function,
804 // as they are part of the same "inference environment".
805 let outer_def_id = tcx.closure_base_def_id(def_id);
806 if outer_def_id != def_id {
807 return tcx.has_typeck_tables(outer_def_id);
810 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
811 primary_body_of(tcx, id).is_some()
814 fn used_trait_imports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
817 &*tcx.typeck_tables_of(def_id).used_trait_imports
820 fn typeck_tables_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
822 -> &'tcx ty::TypeckTables<'tcx> {
823 // Closures' tables come from their outermost function,
824 // as they are part of the same "inference environment".
825 let outer_def_id = tcx.closure_base_def_id(def_id);
826 if outer_def_id != def_id {
827 return tcx.typeck_tables_of(outer_def_id);
830 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
831 let span = tcx.hir().span_by_hir_id(id);
833 // Figure out what primary body this item has.
834 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
835 span_bug!(span, "can't type-check body of {:?}", def_id);
837 let body = tcx.hir().body(body_id);
839 let tables = Inherited::build(tcx, def_id).enter(|inh| {
840 let param_env = tcx.param_env(def_id);
841 let fcx = if let Some(decl) = fn_decl {
842 let fn_sig = tcx.fn_sig(def_id);
844 check_abi(tcx, span, fn_sig.abi());
846 // Compute the fty from point of view of inside the fn.
848 tcx.liberate_late_bound_regions(def_id, &fn_sig);
850 inh.normalize_associated_types_in(body.value.span,
855 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
858 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
859 let expected_type = tcx.type_of(def_id);
860 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
861 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
863 let revealed_ty = if tcx.features().impl_trait_in_bindings {
864 fcx.instantiate_opaque_types_from_value(
872 // Gather locals in statics (because of block expressions).
873 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
875 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
877 fcx.write_ty(id, revealed_ty);
882 // All type checking constraints were added, try to fallback unsolved variables.
883 fcx.select_obligations_where_possible(false);
884 let mut fallback_has_occurred = false;
885 for ty in &fcx.unsolved_variables() {
886 fallback_has_occurred |= fcx.fallback_if_possible(ty);
888 fcx.select_obligations_where_possible(fallback_has_occurred);
890 // Even though coercion casts provide type hints, we check casts after fallback for
891 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
894 // Closure and generator analysis may run after fallback
895 // because they don't constrain other type variables.
896 fcx.closure_analyze(body);
897 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
898 fcx.resolve_generator_interiors(def_id);
900 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
901 let ty = fcx.normalize_ty(span, ty);
902 fcx.require_type_is_sized(ty, span, code);
904 fcx.select_all_obligations_or_error();
906 if fn_decl.is_some() {
907 fcx.regionck_fn(id, body);
909 fcx.regionck_expr(body);
912 fcx.resolve_type_vars_in_body(body)
915 // Consistency check our TypeckTables instance can hold all ItemLocalIds
916 // it will need to hold.
917 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
922 fn check_abi<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: Span, abi: Abi) {
923 if !tcx.sess.target.target.is_abi_supported(abi) {
924 struct_span_err!(tcx.sess, span, E0570,
925 "The ABI `{}` is not supported for the current target", abi).emit()
929 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
930 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
931 parent_id: hir::HirId,
934 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
935 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
938 // infer the variable's type
939 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
940 kind: TypeVariableOriginKind::TypeInference,
943 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
950 // take type that the user specified
951 self.fcx.locals.borrow_mut().insert(nid, typ);
958 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
959 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
960 NestedVisitorMap::None
963 // Add explicitly-declared locals.
964 fn visit_local(&mut self, local: &'gcx hir::Local) {
965 let local_ty = match local.ty {
967 let o_ty = self.fcx.to_ty(&ty);
969 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
970 self.fcx.instantiate_opaque_types_from_value(
978 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
979 &UserType::Ty(revealed_ty)
981 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
982 ty.hir_id, o_ty, revealed_ty, c_ty);
983 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
985 Some(LocalTy { decl_ty: o_ty, revealed_ty })
989 self.assign(local.span, local.hir_id, local_ty);
991 debug!("Local variable {:?} is assigned type {}",
993 self.fcx.ty_to_string(
994 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
995 intravisit::walk_local(self, local);
998 // Add pattern bindings.
999 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
1000 if let PatKind::Binding(_, _, ident, _) = p.node {
1001 let var_ty = self.assign(p.span, p.hir_id, None);
1003 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
1004 if !self.fcx.tcx.features().unsized_locals {
1005 self.fcx.require_type_is_sized(var_ty, p.span,
1006 traits::VariableType(node_id));
1009 debug!("Pattern binding {} is assigned to {} with type {:?}",
1011 self.fcx.ty_to_string(
1012 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1015 intravisit::walk_pat(self, p);
1018 // Don't descend into the bodies of nested closures
1019 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1020 _: hir::BodyId, _: Span, _: hir::HirId) { }
1023 /// When `check_fn` is invoked on a generator (i.e., a body that
1024 /// includes yield), it returns back some information about the yield
1026 struct GeneratorTypes<'tcx> {
1027 /// Type of value that is yielded.
1030 /// Types that are captured (see `GeneratorInterior` for more).
1033 /// Indicates if the generator is movable or static (immovable).
1034 movability: hir::GeneratorMovability,
1037 /// Helper used for fns and closures. Does the grungy work of checking a function
1038 /// body and returns the function context used for that purpose, since in the case of a fn item
1039 /// there is still a bit more to do.
1042 /// * inherited: other fields inherited from the enclosing fn (if any)
1043 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1044 param_env: ty::ParamEnv<'tcx>,
1045 fn_sig: ty::FnSig<'tcx>,
1046 decl: &'gcx hir::FnDecl,
1048 body: &'gcx hir::Body,
1049 can_be_generator: Option<hir::GeneratorMovability>)
1050 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1052 let mut fn_sig = fn_sig.clone();
1054 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1056 // Create the function context. This is either derived from scratch or,
1057 // in the case of closures, based on the outer context.
1058 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1059 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1061 let declared_ret_ty = fn_sig.output();
1062 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1063 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1064 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1065 fn_sig = fcx.tcx.mk_fn_sig(
1066 fn_sig.inputs().iter().cloned(),
1073 let span = body.value.span;
1075 if body.is_generator && can_be_generator.is_some() {
1076 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1077 kind: TypeVariableOriginKind::TypeInference,
1080 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1081 fcx.yield_ty = Some(yield_ty);
1084 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1085 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1086 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1088 // Add formal parameters.
1089 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1090 // Check the pattern.
1091 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1092 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1094 // Check that argument is Sized.
1095 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1096 // for simple cases like `fn foo(x: Trait)`,
1097 // where we would error once on the parameter as a whole, and once on the binding `x`.
1098 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1099 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1102 fcx.write_ty(arg.hir_id, arg_ty);
1105 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1107 fcx.check_return_expr(&body.value);
1109 // We insert the deferred_generator_interiors entry after visiting the body.
1110 // This ensures that all nested generators appear before the entry of this generator.
1111 // resolve_generator_interiors relies on this property.
1112 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1113 let interior = fcx.next_ty_var(TypeVariableOrigin {
1114 kind: TypeVariableOriginKind::MiscVariable,
1117 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1118 Some(GeneratorTypes {
1119 yield_ty: fcx.yield_ty.unwrap(),
1121 movability: can_be_generator.unwrap(),
1127 // Finalize the return check by taking the LUB of the return types
1128 // we saw and assigning it to the expected return type. This isn't
1129 // really expected to fail, since the coercions would have failed
1130 // earlier when trying to find a LUB.
1132 // However, the behavior around `!` is sort of complex. In the
1133 // event that the `actual_return_ty` comes back as `!`, that
1134 // indicates that the fn either does not return or "returns" only
1135 // values of type `!`. In this case, if there is an expected
1136 // return type that is *not* `!`, that should be ok. But if the
1137 // return type is being inferred, we want to "fallback" to `!`:
1139 // let x = move || panic!();
1141 // To allow for that, I am creating a type variable with diverging
1142 // fallback. This was deemed ever so slightly better than unifying
1143 // the return value with `!` because it allows for the caller to
1144 // make more assumptions about the return type (e.g., they could do
1146 // let y: Option<u32> = Some(x());
1148 // which would then cause this return type to become `u32`, not
1150 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1151 let mut actual_return_ty = coercion.complete(&fcx);
1152 if actual_return_ty.is_never() {
1153 actual_return_ty = fcx.next_diverging_ty_var(
1154 TypeVariableOrigin {
1155 kind: TypeVariableOriginKind::DivergingFn,
1160 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1162 // Check that the main return type implements the termination trait.
1163 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1164 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1165 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1166 if main_id == fn_id {
1167 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1168 let trait_ref = ty::TraitRef::new(term_id, substs);
1169 let return_ty_span = decl.output.span();
1170 let cause = traits::ObligationCause::new(
1171 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1173 inherited.register_predicate(
1174 traits::Obligation::new(
1175 cause, param_env, trait_ref.to_predicate()));
1180 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1181 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1182 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1183 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1184 // at this point we don't care if there are duplicate handlers or if the handler has
1185 // the wrong signature as this value we'll be used when writing metadata and that
1186 // only happens if compilation succeeded
1187 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1189 if declared_ret_ty.sty != ty::Never {
1190 fcx.tcx.sess.span_err(
1192 "return type should be `!`",
1196 let inputs = fn_sig.inputs();
1197 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1198 if inputs.len() == 1 {
1199 let arg_is_panic_info = match inputs[0].sty {
1200 ty::Ref(region, ty, mutbl) => match ty.sty {
1201 ty::Adt(ref adt, _) => {
1202 adt.did == panic_info_did &&
1203 mutbl == hir::Mutability::MutImmutable &&
1204 *region != RegionKind::ReStatic
1211 if !arg_is_panic_info {
1212 fcx.tcx.sess.span_err(
1213 decl.inputs[0].span,
1214 "argument should be `&PanicInfo`",
1218 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1219 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1220 if !generics.params.is_empty() {
1221 fcx.tcx.sess.span_err(
1223 "should have no type parameters",
1229 let span = fcx.tcx.sess.source_map().def_span(span);
1230 fcx.tcx.sess.span_err(span, "function should have one argument");
1233 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1238 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1239 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1240 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1241 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1242 if declared_ret_ty.sty != ty::Never {
1243 fcx.tcx.sess.span_err(
1245 "return type should be `!`",
1249 let inputs = fn_sig.inputs();
1250 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1251 if inputs.len() == 1 {
1252 let arg_is_alloc_layout = match inputs[0].sty {
1253 ty::Adt(ref adt, _) => {
1254 adt.did == alloc_layout_did
1259 if !arg_is_alloc_layout {
1260 fcx.tcx.sess.span_err(
1261 decl.inputs[0].span,
1262 "argument should be `Layout`",
1266 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1267 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1268 if !generics.params.is_empty() {
1269 fcx.tcx.sess.span_err(
1271 "`#[alloc_error_handler]` function should have no type \
1278 let span = fcx.tcx.sess.source_map().def_span(span);
1279 fcx.tcx.sess.span_err(span, "function should have one argument");
1282 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1290 fn check_struct<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1293 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1294 let def = tcx.adt_def(def_id);
1295 def.destructor(tcx); // force the destructor to be evaluated
1296 check_representable(tcx, span, def_id);
1298 if def.repr.simd() {
1299 check_simd(tcx, span, def_id);
1302 check_transparent(tcx, span, def_id);
1303 check_packed(tcx, span, def_id);
1306 fn check_union<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1309 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1310 let def = tcx.adt_def(def_id);
1311 def.destructor(tcx); // force the destructor to be evaluated
1312 check_representable(tcx, span, def_id);
1314 check_packed(tcx, span, def_id);
1317 fn check_opaque<'a, 'tcx>(
1318 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1320 substs: SubstsRef<'tcx>,
1323 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1324 let mut err = struct_span_err!(
1325 tcx.sess, span, E0720,
1326 "opaque type expands to a recursive type",
1328 err.span_label(span, "expands to self-referential type");
1329 if let ty::Opaque(..) = partially_expanded_type.sty {
1330 err.note("type resolves to itself");
1332 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1338 pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item) {
1340 "check_item_type(it.hir_id={}, it.name={})",
1342 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1344 let _indenter = indenter();
1346 // Consts can play a role in type-checking, so they are included here.
1347 hir::ItemKind::Static(..) => {
1348 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1349 tcx.typeck_tables_of(def_id);
1350 maybe_check_static_with_link_section(tcx, def_id, it.span);
1352 hir::ItemKind::Const(..) => {
1353 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1355 hir::ItemKind::Enum(ref enum_definition, _) => {
1356 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1358 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1359 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1360 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1361 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1362 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1363 check_impl_items_against_trait(
1370 let trait_def_id = impl_trait_ref.def_id;
1371 check_on_unimplemented(tcx, trait_def_id, it);
1374 hir::ItemKind::Trait(..) => {
1375 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1376 check_on_unimplemented(tcx, def_id, it);
1378 hir::ItemKind::Struct(..) => {
1379 check_struct(tcx, it.hir_id, it.span);
1381 hir::ItemKind::Union(..) => {
1382 check_union(tcx, it.hir_id, it.span);
1384 hir::ItemKind::Existential(..) => {
1385 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1387 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1388 check_opaque(tcx, def_id, substs, it.span);
1390 hir::ItemKind::Ty(..) => {
1391 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1392 let pty_ty = tcx.type_of(def_id);
1393 let generics = tcx.generics_of(def_id);
1394 check_bounds_are_used(tcx, &generics, pty_ty);
1396 hir::ItemKind::ForeignMod(ref m) => {
1397 check_abi(tcx, it.span, m.abi);
1399 if m.abi == Abi::RustIntrinsic {
1400 for item in &m.items {
1401 intrinsic::check_intrinsic_type(tcx, item);
1403 } else if m.abi == Abi::PlatformIntrinsic {
1404 for item in &m.items {
1405 intrinsic::check_platform_intrinsic_type(tcx, item);
1408 for item in &m.items {
1409 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1410 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1411 let mut err = struct_span_err!(
1415 "foreign items may not have type parameters"
1417 err.span_label(item.span, "can't have type parameters");
1418 // FIXME: once we start storing spans for type arguments, turn this into a
1421 "use specialization instead of type parameters by replacing them \
1422 with concrete types like `u32`",
1427 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1428 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1433 _ => { /* nothing to do */ }
1437 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_, '_>, id: DefId, span: Span) {
1438 // Only restricted on wasm32 target for now
1439 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1443 // If `#[link_section]` is missing, then nothing to verify
1444 let attrs = tcx.codegen_fn_attrs(id);
1445 if attrs.link_section.is_none() {
1449 // For the wasm32 target statics with #[link_section] are placed into custom
1450 // sections of the final output file, but this isn't link custom sections of
1451 // other executable formats. Namely we can only embed a list of bytes,
1452 // nothing with pointers to anything else or relocations. If any relocation
1453 // show up, reject them here.
1454 let instance = ty::Instance::mono(tcx, id);
1455 let cid = GlobalId {
1459 let param_env = ty::ParamEnv::reveal_all();
1460 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1461 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1464 bug!("Matching on non-ByRef static")
1466 if alloc.relocations.len() != 0 {
1467 let msg = "statics with a custom `#[link_section]` must be a \
1468 simple list of bytes on the wasm target with no \
1469 extra levels of indirection such as references";
1470 tcx.sess.span_err(span, msg);
1475 fn check_on_unimplemented<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1476 trait_def_id: DefId,
1478 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1479 // an error would be reported if this fails.
1480 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1483 fn report_forbidden_specialization<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1484 impl_item: &hir::ImplItem,
1487 let mut err = struct_span_err!(
1488 tcx.sess, impl_item.span, E0520,
1489 "`{}` specializes an item from a parent `impl`, but \
1490 that item is not marked `default`",
1492 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1495 match tcx.span_of_impl(parent_impl) {
1497 err.span_label(span, "parent `impl` is here");
1498 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1502 err.note(&format!("parent implementation is in crate `{}`", cname));
1509 fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1510 trait_def: &ty::TraitDef,
1511 trait_item: &ty::AssocItem,
1513 impl_item: &hir::ImplItem)
1515 let ancestors = trait_def.ancestors(tcx, impl_id);
1517 let kind = match impl_item.node {
1518 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1519 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1520 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1521 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1524 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1525 .map(|node_item| node_item.map(|parent| parent.defaultness));
1527 if let Some(parent) = parent {
1528 if tcx.impl_item_is_final(&parent) {
1529 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1535 fn check_impl_items_against_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1538 impl_trait_ref: ty::TraitRef<'tcx>,
1539 impl_item_refs: &[hir::ImplItemRef]) {
1540 let impl_span = tcx.sess.source_map().def_span(impl_span);
1542 // If the trait reference itself is erroneous (so the compilation is going
1543 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1544 // isn't populated for such impls.
1545 if impl_trait_ref.references_error() { return; }
1547 // Locate trait definition and items
1548 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1549 let mut overridden_associated_type = None;
1551 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1553 // Check existing impl methods to see if they are both present in trait
1554 // and compatible with trait signature
1555 for impl_item in impl_items() {
1556 let ty_impl_item = tcx.associated_item(
1557 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1558 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1559 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1560 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1562 // Not compatible, but needed for the error message
1563 tcx.associated_items(impl_trait_ref.def_id)
1564 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1567 // Check that impl definition matches trait definition
1568 if let Some(ty_trait_item) = ty_trait_item {
1569 match impl_item.node {
1570 hir::ImplItemKind::Const(..) => {
1571 // Find associated const definition.
1572 if ty_trait_item.kind == ty::AssocKind::Const {
1573 compare_const_impl(tcx,
1579 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1580 "item `{}` is an associated const, \
1581 which doesn't match its trait `{}`",
1584 err.span_label(impl_item.span, "does not match trait");
1585 // We can only get the spans from local trait definition
1586 // Same for E0324 and E0325
1587 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1588 err.span_label(trait_span, "item in trait");
1593 hir::ImplItemKind::Method(..) => {
1594 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1595 if ty_trait_item.kind == ty::AssocKind::Method {
1596 compare_impl_method(tcx,
1603 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1604 "item `{}` is an associated method, \
1605 which doesn't match its trait `{}`",
1608 err.span_label(impl_item.span, "does not match trait");
1609 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1610 err.span_label(trait_span, "item in trait");
1615 hir::ImplItemKind::Existential(..) |
1616 hir::ImplItemKind::Type(_) => {
1617 if ty_trait_item.kind == ty::AssocKind::Type {
1618 if ty_trait_item.defaultness.has_value() {
1619 overridden_associated_type = Some(impl_item);
1622 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1623 "item `{}` is an associated type, \
1624 which doesn't match its trait `{}`",
1627 err.span_label(impl_item.span, "does not match trait");
1628 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1629 err.span_label(trait_span, "item in trait");
1636 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1640 // Check for missing items from trait
1641 let mut missing_items = Vec::new();
1642 let mut invalidated_items = Vec::new();
1643 let associated_type_overridden = overridden_associated_type.is_some();
1644 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1645 let is_implemented = trait_def.ancestors(tcx, impl_id)
1646 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1648 .map(|node_item| !node_item.node.is_from_trait())
1651 if !is_implemented && !tcx.impl_is_default(impl_id) {
1652 if !trait_item.defaultness.has_value() {
1653 missing_items.push(trait_item);
1654 } else if associated_type_overridden {
1655 invalidated_items.push(trait_item.ident);
1660 if !missing_items.is_empty() {
1661 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1662 "not all trait items implemented, missing: `{}`",
1663 missing_items.iter()
1664 .map(|trait_item| trait_item.ident.to_string())
1665 .collect::<Vec<_>>().join("`, `"));
1666 err.span_label(impl_span, format!("missing `{}` in implementation",
1667 missing_items.iter()
1668 .map(|trait_item| trait_item.ident.to_string())
1669 .collect::<Vec<_>>().join("`, `")));
1670 for trait_item in missing_items {
1671 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1672 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1674 err.note_trait_signature(trait_item.ident.to_string(),
1675 trait_item.signature(tcx));
1681 if !invalidated_items.is_empty() {
1682 let invalidator = overridden_associated_type.unwrap();
1683 span_err!(tcx.sess, invalidator.span, E0399,
1684 "the following trait items need to be reimplemented \
1685 as `{}` was overridden: `{}`",
1687 invalidated_items.iter()
1688 .map(|name| name.to_string())
1689 .collect::<Vec<_>>().join("`, `"))
1693 /// Checks whether a type can be represented in memory. In particular, it
1694 /// identifies types that contain themselves without indirection through a
1695 /// pointer, which would mean their size is unbounded.
1696 fn check_representable<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1700 let rty = tcx.type_of(item_def_id);
1702 // Check that it is possible to represent this type. This call identifies
1703 // (1) types that contain themselves and (2) types that contain a different
1704 // recursive type. It is only necessary to throw an error on those that
1705 // contain themselves. For case 2, there must be an inner type that will be
1706 // caught by case 1.
1707 match rty.is_representable(tcx, sp) {
1708 Representability::SelfRecursive(spans) => {
1709 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1711 err.span_label(span, "recursive without indirection");
1716 Representability::Representable | Representability::ContainsRecursive => (),
1721 pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1722 let t = tcx.type_of(def_id);
1723 if let ty::Adt(def, substs) = t.sty {
1724 if def.is_struct() {
1725 let fields = &def.non_enum_variant().fields;
1726 if fields.is_empty() {
1727 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1730 let e = fields[0].ty(tcx, substs);
1731 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1732 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1733 .span_label(sp, "SIMD elements must have the same type")
1738 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1739 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1741 span_err!(tcx.sess, sp, E0077,
1742 "SIMD vector element type should be machine type");
1750 fn check_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1751 let repr = tcx.adt_def(def_id).repr;
1753 for attr in tcx.get_attrs(def_id).iter() {
1754 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1755 if let attr::ReprPacked(pack) = r {
1756 if pack != repr.pack {
1757 struct_span_err!(tcx.sess, sp, E0634,
1758 "type has conflicting packed representation hints").emit();
1764 struct_span_err!(tcx.sess, sp, E0587,
1765 "type has conflicting packed and align representation hints").emit();
1767 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1768 struct_span_err!(tcx.sess, sp, E0588,
1769 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1774 fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1776 stack: &mut Vec<DefId>) -> bool {
1777 let t = tcx.type_of(def_id);
1778 if stack.contains(&def_id) {
1779 debug!("check_packed_inner: {:?} is recursive", t);
1782 if let ty::Adt(def, substs) = t.sty {
1783 if def.is_struct() || def.is_union() {
1784 if tcx.adt_def(def.did).repr.align > 0 {
1787 // push struct def_id before checking fields
1789 for field in &def.non_enum_variant().fields {
1790 let f = field.ty(tcx, substs);
1791 if let ty::Adt(def, _) = f.sty {
1792 if check_packed_inner(tcx, def.did, stack) {
1797 // only need to pop if not early out
1804 fn check_transparent<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId) {
1805 let adt = tcx.adt_def(def_id);
1806 if !adt.repr.transparent() {
1810 // For each field, figure out if it's known to be a ZST and align(1)
1811 let field_infos = adt.non_enum_variant().fields.iter().map(|field| {
1812 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1813 let param_env = tcx.param_env(field.did);
1814 let layout = tcx.layout_of(param_env.and(ty));
1815 // We are currently checking the type this field came from, so it must be local
1816 let span = tcx.hir().span_if_local(field.did).unwrap();
1817 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1818 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1822 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1823 let non_zst_count = non_zst_fields.clone().count();
1824 if non_zst_count != 1 {
1825 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1826 struct_span_err!(tcx.sess, sp, E0690,
1827 "transparent struct needs exactly one non-zero-sized field, but has {}",
1829 .span_note(field_spans, "non-zero-sized field")
1832 for (span, zst, align1) in field_infos {
1834 span_err!(tcx.sess, span, E0691,
1835 "zero-sized field in transparent struct has alignment larger than 1");
1840 #[allow(trivial_numeric_casts)]
1841 pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
1843 vs: &'tcx [hir::Variant],
1845 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1846 let def = tcx.adt_def(def_id);
1847 def.destructor(tcx); // force the destructor to be evaluated
1850 let attributes = tcx.get_attrs(def_id);
1851 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1853 tcx.sess, attr.span, E0084,
1854 "unsupported representation for zero-variant enum")
1855 .span_label(sp, "zero-variant enum")
1860 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1861 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1862 if !tcx.features().repr128 {
1863 emit_feature_err(&tcx.sess.parse_sess,
1866 GateIssue::Language,
1867 "repr with 128-bit type is unstable");
1872 if let Some(ref e) = v.node.disr_expr {
1873 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1877 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1878 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1879 // Check for duplicate discriminant values
1880 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1881 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1882 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1883 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1884 let i_span = match variant_i.node.disr_expr {
1885 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1886 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1888 let span = match v.node.disr_expr {
1889 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1892 struct_span_err!(tcx.sess, span, E0081,
1893 "discriminant value `{}` already exists", disr_vals[i])
1894 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1895 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1898 disr_vals.push(discr);
1901 check_representable(tcx, sp, def_id);
1904 fn report_unexpected_variant_res<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
1908 span_err!(tcx.sess, span, E0533,
1909 "expected unit struct/variant or constant, found {} `{}`",
1911 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1914 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1915 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
1917 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1918 -> &'tcx ty::GenericPredicates<'tcx>
1921 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1922 let item_id = tcx.hir().ty_param_owner(hir_id);
1923 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1924 let generics = tcx.generics_of(item_def_id);
1925 let index = generics.param_def_id_to_index[&def_id];
1926 tcx.arena.alloc(ty::GenericPredicates {
1928 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1930 ty::Predicate::Trait(ref data)
1931 if data.skip_binder().self_ty().is_param(index) => {
1932 // HACK(eddyb) should get the original `Span`.
1933 let span = tcx.def_span(def_id);
1934 Some((predicate, span))
1944 def: Option<&ty::GenericParamDef>,
1946 ) -> Option<ty::Region<'tcx>> {
1948 Some(def) => infer::EarlyBoundRegion(span, def.name),
1949 None => infer::MiscVariable(span)
1951 Some(self.next_region_var(v))
1954 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
1955 if let Some(param) = param {
1956 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
1961 self.next_ty_var(TypeVariableOrigin {
1962 kind: TypeVariableOriginKind::TypeInference,
1971 param: Option<&ty::GenericParamDef>,
1973 ) -> &'tcx Const<'tcx> {
1974 if let Some(param) = param {
1975 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
1980 self.next_const_var(ty, ConstVariableOrigin {
1981 kind: ConstVariableOriginKind::ConstInference,
1987 fn projected_ty_from_poly_trait_ref(&self,
1990 poly_trait_ref: ty::PolyTraitRef<'tcx>)
1993 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
1995 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
1999 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2002 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2003 if ty.has_escaping_bound_vars() {
2004 ty // FIXME: normalization and escaping regions
2006 self.normalize_associated_types_in(span, &ty)
2010 fn set_tainted_by_errors(&self) {
2011 self.infcx.set_tainted_by_errors()
2014 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2015 self.write_ty(hir_id, ty)
2019 /// Controls whether the arguments are tupled. This is used for the call
2022 /// Tupling means that all call-side arguments are packed into a tuple and
2023 /// passed as a single parameter. For example, if tupling is enabled, this
2026 /// fn f(x: (isize, isize))
2028 /// Can be called as:
2035 #[derive(Clone, Eq, PartialEq)]
2036 enum TupleArgumentsFlag {
2041 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2042 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2043 param_env: ty::ParamEnv<'tcx>,
2044 body_id: hir::HirId)
2045 -> FnCtxt<'a, 'gcx, 'tcx> {
2049 err_count_on_creation: inh.tcx.sess.err_count(),
2051 ret_coercion_span: RefCell::new(None),
2053 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2054 hir::CRATE_HIR_ID)),
2055 diverges: Cell::new(Diverges::Maybe),
2056 has_errors: Cell::new(false),
2057 enclosing_breakables: RefCell::new(EnclosingBreakables {
2059 by_id: Default::default(),
2065 pub fn sess(&self) -> &Session {
2069 pub fn err_count_since_creation(&self) -> usize {
2070 self.tcx.sess.err_count() - self.err_count_on_creation
2073 /// Produces warning on the given node, if the current point in the
2074 /// function is unreachable, and there hasn't been another warning.
2075 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2076 if self.diverges.get() == Diverges::Always &&
2077 // If span arose from a desugaring of `if` then it is the condition itself,
2078 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2079 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2080 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2081 self.diverges.set(Diverges::WarnedAlways);
2083 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2085 let msg = format!("unreachable {}", kind);
2086 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2092 code: ObligationCauseCode<'tcx>)
2093 -> ObligationCause<'tcx> {
2094 ObligationCause::new(span, self.body_id, code)
2097 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2098 self.cause(span, ObligationCauseCode::MiscObligation)
2101 /// Resolves type variables in `ty` if possible. Unlike the infcx
2102 /// version (resolve_vars_if_possible), this version will
2103 /// also select obligations if it seems useful, in an effort
2104 /// to get more type information.
2105 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2106 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2108 // No Infer()? Nothing needs doing.
2109 if !ty.has_infer_types() {
2110 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2114 // If `ty` is a type variable, see whether we already know what it is.
2115 ty = self.resolve_vars_if_possible(&ty);
2116 if !ty.has_infer_types() {
2117 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2121 // If not, try resolving pending obligations as much as
2122 // possible. This can help substantially when there are
2123 // indirect dependencies that don't seem worth tracking
2125 self.select_obligations_where_possible(false);
2126 ty = self.resolve_vars_if_possible(&ty);
2128 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2132 fn record_deferred_call_resolution(&self,
2133 closure_def_id: DefId,
2134 r: DeferredCallResolution<'gcx, 'tcx>) {
2135 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2136 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2139 fn remove_deferred_call_resolutions(&self,
2140 closure_def_id: DefId)
2141 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2143 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2144 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2147 pub fn tag(&self) -> String {
2148 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2149 format!("{:?}", self_ptr)
2152 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2153 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2154 span_bug!(span, "no type for local variable {}",
2155 self.tcx.hir().hir_to_string(nid))
2160 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2161 debug!("write_ty({:?}, {:?}) in fcx {}",
2162 id, self.resolve_vars_if_possible(&ty), self.tag());
2163 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2165 if ty.references_error() {
2166 self.has_errors.set(true);
2167 self.set_tainted_by_errors();
2171 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2172 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2175 pub fn write_method_call(&self,
2177 method: MethodCallee<'tcx>) {
2178 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2181 .type_dependent_defs_mut()
2182 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2184 self.write_substs(hir_id, method.substs);
2186 // When the method is confirmed, the `method.substs` includes
2187 // parameters from not just the method, but also the impl of
2188 // the method -- in particular, the `Self` type will be fully
2189 // resolved. However, those are not something that the "user
2190 // specified" -- i.e., those types come from the inferred type
2191 // of the receiver, not something the user wrote. So when we
2192 // create the user-substs, we want to replace those earlier
2193 // types with just the types that the user actually wrote --
2194 // that is, those that appear on the *method itself*.
2196 // As an example, if the user wrote something like
2197 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2198 // type of `foo` (possibly adjusted), but we don't want to
2199 // include that. We want just the `[_, u32]` part.
2200 if !method.substs.is_noop() {
2201 let method_generics = self.tcx.generics_of(method.def_id);
2202 if !method_generics.params.is_empty() {
2203 let user_type_annotation = self.infcx.probe(|_| {
2204 let user_substs = UserSubsts {
2205 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2206 let i = param.index as usize;
2207 if i < method_generics.parent_count {
2208 self.infcx.var_for_def(DUMMY_SP, param)
2213 user_self_ty: None, // not relevant here
2216 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2222 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2223 self.write_user_type_annotation(hir_id, user_type_annotation);
2228 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2229 if !substs.is_noop() {
2230 debug!("write_substs({:?}, {:?}) in fcx {}",
2235 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2239 /// Given the substs that we just converted from the HIR, try to
2240 /// canonicalize them and store them as user-given substitutions
2241 /// (i.e., substitutions that must be respected by the NLL check).
2243 /// This should be invoked **before any unifications have
2244 /// occurred**, so that annotations like `Vec<_>` are preserved
2246 pub fn write_user_type_annotation_from_substs(
2250 substs: SubstsRef<'tcx>,
2251 user_self_ty: Option<UserSelfTy<'tcx>>,
2254 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2255 user_self_ty={:?} in fcx {}",
2256 hir_id, def_id, substs, user_self_ty, self.tag(),
2259 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2260 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2261 &UserType::TypeOf(def_id, UserSubsts {
2266 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2267 self.write_user_type_annotation(hir_id, canonicalized);
2271 pub fn write_user_type_annotation(
2274 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2277 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2278 hir_id, canonical_user_type_annotation, self.tag(),
2281 if !canonical_user_type_annotation.is_identity() {
2282 self.tables.borrow_mut().user_provided_types_mut().insert(
2283 hir_id, canonical_user_type_annotation
2286 debug!("write_user_type_annotation: skipping identity substs");
2290 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2291 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2297 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2298 Entry::Vacant(entry) => { entry.insert(adj); },
2299 Entry::Occupied(mut entry) => {
2300 debug!(" - composing on top of {:?}", entry.get());
2301 match (&entry.get()[..], &adj[..]) {
2302 // Applying any adjustment on top of a NeverToAny
2303 // is a valid NeverToAny adjustment, because it can't
2305 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2307 Adjustment { kind: Adjust::Deref(_), .. },
2308 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2310 Adjustment { kind: Adjust::Deref(_), .. },
2311 .. // Any following adjustments are allowed.
2313 // A reborrow has no effect before a dereference.
2315 // FIXME: currently we never try to compose autoderefs
2316 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2318 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2319 expr, entry.get(), adj)
2321 *entry.get_mut() = adj;
2326 /// Basically whenever we are converting from a type scheme into
2327 /// the fn body space, we always want to normalize associated
2328 /// types as well. This function combines the two.
2329 fn instantiate_type_scheme<T>(&self,
2331 substs: SubstsRef<'tcx>,
2334 where T : TypeFoldable<'tcx>
2336 let value = value.subst(self.tcx, substs);
2337 let result = self.normalize_associated_types_in(span, &value);
2338 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2345 /// As `instantiate_type_scheme`, but for the bounds found in a
2346 /// generic type scheme.
2347 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2348 -> ty::InstantiatedPredicates<'tcx> {
2349 let bounds = self.tcx.predicates_of(def_id);
2350 let result = bounds.instantiate(self.tcx, substs);
2351 let result = self.normalize_associated_types_in(span, &result);
2352 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2359 /// Replaces the opaque types from the given value with type variables,
2360 /// and records the `OpaqueTypeMap` for later use during writeback. See
2361 /// `InferCtxt::instantiate_opaque_types` for more details.
2362 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2364 parent_id: hir::HirId,
2367 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2368 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2372 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2373 self.instantiate_opaque_types(
2381 let mut opaque_types = self.opaque_types.borrow_mut();
2382 for (ty, decl) in opaque_type_map {
2383 let old_value = opaque_types.insert(ty, decl);
2384 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2390 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2391 where T : TypeFoldable<'tcx>
2393 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2396 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2398 where T : TypeFoldable<'tcx>
2400 self.inh.partially_normalize_associated_types_in(span,
2406 pub fn require_type_meets(&self,
2409 code: traits::ObligationCauseCode<'tcx>,
2412 self.register_bound(
2415 traits::ObligationCause::new(span, self.body_id, code));
2418 pub fn require_type_is_sized(&self,
2421 code: traits::ObligationCauseCode<'tcx>)
2423 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2424 self.require_type_meets(ty, span, code, lang_item);
2427 pub fn require_type_is_sized_deferred(&self,
2430 code: traits::ObligationCauseCode<'tcx>)
2432 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2435 pub fn register_bound(&self,
2438 cause: traits::ObligationCause<'tcx>)
2440 self.fulfillment_cx.borrow_mut()
2441 .register_bound(self, self.param_env, ty, def_id, cause);
2444 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2445 let t = AstConv::ast_ty_to_ty(self, ast_t);
2446 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2450 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2451 let ty = self.to_ty(ast_ty);
2452 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2454 if Self::can_contain_user_lifetime_bounds(ty) {
2455 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2456 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2457 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2463 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2464 AstConv::ast_const_to_const(self, ast_c, ty)
2467 // If the type given by the user has free regions, save it for later, since
2468 // NLL would like to enforce those. Also pass in types that involve
2469 // projections, since those can resolve to `'static` bounds (modulo #54940,
2470 // which hopefully will be fixed by the time you see this comment, dear
2471 // reader, although I have my doubts). Also pass in types with inference
2472 // types, because they may be repeated. Other sorts of things are already
2473 // sufficiently enforced with erased regions. =)
2474 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2476 T: TypeFoldable<'tcx>
2478 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2481 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2482 match self.tables.borrow().node_types().get(id) {
2484 None if self.is_tainted_by_errors() => self.tcx.types.err,
2486 let node_id = self.tcx.hir().hir_to_node_id(id);
2487 bug!("no type for node {}: {} in fcx {}",
2488 node_id, self.tcx.hir().node_to_string(node_id),
2494 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2495 /// outlive the region `r`.
2496 pub fn register_wf_obligation(&self,
2499 code: traits::ObligationCauseCode<'tcx>)
2501 // WF obligations never themselves fail, so no real need to give a detailed cause:
2502 let cause = traits::ObligationCause::new(span, self.body_id, code);
2503 self.register_predicate(traits::Obligation::new(cause,
2505 ty::Predicate::WellFormed(ty)));
2508 /// Registers obligations that all types appearing in `substs` are well-formed.
2509 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2510 for ty in substs.types() {
2511 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2515 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2516 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2517 /// trait/region obligations.
2519 /// For example, if there is a function:
2522 /// fn foo<'a,T:'a>(...)
2525 /// and a reference:
2531 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2532 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2533 pub fn add_obligations_for_parameters(&self,
2534 cause: traits::ObligationCause<'tcx>,
2535 predicates: &ty::InstantiatedPredicates<'tcx>)
2537 assert!(!predicates.has_escaping_bound_vars());
2539 debug!("add_obligations_for_parameters(predicates={:?})",
2542 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2543 self.register_predicate(obligation);
2547 // FIXME(arielb1): use this instead of field.ty everywhere
2548 // Only for fields! Returns <none> for methods>
2549 // Indifferent to privacy flags
2550 pub fn field_ty(&self,
2552 field: &'tcx ty::FieldDef,
2553 substs: SubstsRef<'tcx>)
2556 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2559 fn check_casts(&self) {
2560 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2561 for cast in deferred_cast_checks.drain(..) {
2566 fn resolve_generator_interiors(&self, def_id: DefId) {
2567 let mut generators = self.deferred_generator_interiors.borrow_mut();
2568 for (body_id, interior) in generators.drain(..) {
2569 self.select_obligations_where_possible(false);
2570 generator_interior::resolve_interior(self, def_id, body_id, interior);
2574 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2575 // Non-numerics get replaced with ! or () (depending on whether
2576 // feature(never_type) is enabled, unconstrained ints with i32,
2577 // unconstrained floats with f64.
2578 // Fallback becomes very dubious if we have encountered type-checking errors.
2579 // In that case, fallback to Error.
2580 // The return value indicates whether fallback has occurred.
2581 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2582 use rustc::ty::error::UnconstrainedNumeric::Neither;
2583 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2585 assert!(ty.is_ty_infer());
2586 let fallback = match self.type_is_unconstrained_numeric(ty) {
2587 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2588 UnconstrainedInt => self.tcx.types.i32,
2589 UnconstrainedFloat => self.tcx.types.f64,
2590 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2591 Neither => return false,
2593 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2594 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2598 fn select_all_obligations_or_error(&self) {
2599 debug!("select_all_obligations_or_error");
2600 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2601 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2605 /// Select as many obligations as we can at present.
2606 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2607 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2608 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2612 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2613 /// returns a type of `&T`, but the actual type we assign to the
2614 /// *expression* is `T`. So this function just peels off the return
2615 /// type by one layer to yield `T`.
2616 fn make_overloaded_place_return_type(&self,
2617 method: MethodCallee<'tcx>)
2618 -> ty::TypeAndMut<'tcx>
2620 // extract method return type, which will be &T;
2621 let ret_ty = method.sig.output();
2623 // method returns &T, but the type as visible to user is T, so deref
2624 ret_ty.builtin_deref(true).unwrap()
2627 fn lookup_indexing(&self,
2629 base_expr: &'gcx hir::Expr,
2633 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2635 // FIXME(#18741) -- this is almost but not quite the same as the
2636 // autoderef that normal method probing does. They could likely be
2639 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2640 let mut result = None;
2641 while result.is_none() && autoderef.next().is_some() {
2642 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2644 autoderef.finalize(self);
2648 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2649 /// (and otherwise adjust) `base_expr`, looking for a type which either
2650 /// supports builtin indexing or overloaded indexing.
2651 /// This loop implements one step in that search; the autoderef loop
2652 /// is implemented by `lookup_indexing`.
2653 fn try_index_step(&self,
2655 base_expr: &hir::Expr,
2656 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2659 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2661 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2662 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2669 for &unsize in &[false, true] {
2670 let mut self_ty = adjusted_ty;
2672 // We only unsize arrays here.
2673 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2674 self_ty = self.tcx.mk_slice(element_ty);
2680 // If some lookup succeeds, write callee into table and extract index/element
2681 // type from the method signature.
2682 // If some lookup succeeded, install method in table
2683 let input_ty = self.next_ty_var(TypeVariableOrigin {
2684 kind: TypeVariableOriginKind::AutoDeref,
2685 span: base_expr.span,
2687 let method = self.try_overloaded_place_op(
2688 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2690 let result = method.map(|ok| {
2691 debug!("try_index_step: success, using overloaded indexing");
2692 let method = self.register_infer_ok_obligations(ok);
2694 let mut adjustments = autoderef.adjust_steps(self, needs);
2695 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2696 let mutbl = match r_mutbl {
2697 hir::MutImmutable => AutoBorrowMutability::Immutable,
2698 hir::MutMutable => AutoBorrowMutability::Mutable {
2699 // Indexing can be desugared to a method call,
2700 // so maybe we could use two-phase here.
2701 // See the documentation of AllowTwoPhase for why that's
2702 // not the case today.
2703 allow_two_phase_borrow: AllowTwoPhase::No,
2706 adjustments.push(Adjustment {
2707 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2708 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2715 adjustments.push(Adjustment {
2716 kind: Adjust::Pointer(PointerCast::Unsize),
2717 target: method.sig.inputs()[0]
2720 self.apply_adjustments(base_expr, adjustments);
2722 self.write_method_call(expr.hir_id, method);
2723 (input_ty, self.make_overloaded_place_return_type(method).ty)
2725 if result.is_some() {
2733 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2734 let (tr, name) = match (op, is_mut) {
2735 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2736 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2737 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2738 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2740 (tr, ast::Ident::with_empty_ctxt(name))
2743 fn try_overloaded_place_op(&self,
2746 arg_tys: &[Ty<'tcx>],
2749 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2751 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2757 // Try Mut first, if needed.
2758 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2759 let method = match (needs, mut_tr) {
2760 (Needs::MutPlace, Some(trait_did)) => {
2761 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2766 // Otherwise, fall back to the immutable version.
2767 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2768 let method = match (method, imm_tr) {
2769 (None, Some(trait_did)) => {
2770 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2772 (method, _) => method,
2778 fn check_method_argument_types(&self,
2781 method: Result<MethodCallee<'tcx>, ()>,
2782 args_no_rcvr: &'gcx [hir::Expr],
2783 tuple_arguments: TupleArgumentsFlag,
2784 expected: Expectation<'tcx>)
2786 let has_error = match method {
2788 method.substs.references_error() || method.sig.references_error()
2793 let err_inputs = self.err_args(args_no_rcvr.len());
2795 let err_inputs = match tuple_arguments {
2796 DontTupleArguments => err_inputs,
2797 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2800 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2801 false, tuple_arguments, None);
2802 return self.tcx.types.err;
2805 let method = method.unwrap();
2806 // HACK(eddyb) ignore self in the definition (see above).
2807 let expected_arg_tys = self.expected_inputs_for_expected_output(
2810 method.sig.output(),
2811 &method.sig.inputs()[1..]
2813 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2814 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2815 self.tcx.hir().span_if_local(method.def_id));
2819 fn self_type_matches_expected_vid(
2821 trait_ref: ty::PolyTraitRef<'tcx>,
2822 expected_vid: ty::TyVid,
2824 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2826 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2827 trait_ref, self_ty, expected_vid
2830 ty::Infer(ty::TyVar(found_vid)) => {
2831 // FIXME: consider using `sub_root_var` here so we
2832 // can see through subtyping.
2833 let found_vid = self.root_var(found_vid);
2834 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2835 expected_vid == found_vid
2841 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2842 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2843 + Captures<'gcx> + 'b
2845 // FIXME: consider using `sub_root_var` here so we
2846 // can see through subtyping.
2847 let ty_var_root = self.root_var(self_ty);
2848 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2849 self_ty, ty_var_root,
2850 self.fulfillment_cx.borrow().pending_obligations());
2854 .pending_obligations()
2856 .filter_map(move |obligation| match obligation.predicate {
2857 ty::Predicate::Projection(ref data) =>
2858 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2859 ty::Predicate::Trait(ref data) =>
2860 Some((data.to_poly_trait_ref(), obligation)),
2861 ty::Predicate::Subtype(..) => None,
2862 ty::Predicate::RegionOutlives(..) => None,
2863 ty::Predicate::TypeOutlives(..) => None,
2864 ty::Predicate::WellFormed(..) => None,
2865 ty::Predicate::ObjectSafe(..) => None,
2866 ty::Predicate::ConstEvaluatable(..) => None,
2867 // N.B., this predicate is created by breaking down a
2868 // `ClosureType: FnFoo()` predicate, where
2869 // `ClosureType` represents some `Closure`. It can't
2870 // possibly be referring to the current closure,
2871 // because we haven't produced the `Closure` for
2872 // this closure yet; this is exactly why the other
2873 // code is looking for a self type of a unresolved
2874 // inference variable.
2875 ty::Predicate::ClosureKind(..) => None,
2876 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2879 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2880 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2881 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2885 /// Generic function that factors out common logic from function calls,
2886 /// method calls and overloaded operators.
2887 fn check_argument_types(&self,
2890 fn_inputs: &[Ty<'tcx>],
2891 expected_arg_tys: &[Ty<'tcx>],
2892 args: &'gcx [hir::Expr],
2894 tuple_arguments: TupleArgumentsFlag,
2895 def_span: Option<Span>) {
2898 // Grab the argument types, supplying fresh type variables
2899 // if the wrong number of arguments were supplied
2900 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2906 // All the input types from the fn signature must outlive the call
2907 // so as to validate implied bounds.
2908 for &fn_input_ty in fn_inputs {
2909 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2912 let expected_arg_count = fn_inputs.len();
2914 let param_count_error = |expected_count: usize,
2919 let mut err = tcx.sess.struct_span_err_with_code(sp,
2920 &format!("this function takes {}{} but {} {} supplied",
2921 if c_variadic { "at least " } else { "" },
2922 potentially_plural_count(expected_count, "parameter"),
2923 potentially_plural_count(arg_count, "parameter"),
2924 if arg_count == 1 {"was"} else {"were"}),
2925 DiagnosticId::Error(error_code.to_owned()));
2927 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2928 err.span_label(def_s, "defined here");
2931 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2932 // remove closing `)` from the span
2933 let sugg_span = sugg_span.shrink_to_lo();
2934 err.span_suggestion(
2936 "expected the unit value `()`; create it with empty parentheses",
2938 Applicability::MachineApplicable);
2940 err.span_label(sp, format!("expected {}{}",
2941 if c_variadic { "at least " } else { "" },
2942 potentially_plural_count(expected_count, "parameter")));
2947 let mut expected_arg_tys = expected_arg_tys.to_vec();
2949 let formal_tys = if tuple_arguments == TupleArguments {
2950 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2951 match tuple_type.sty {
2952 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2953 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2954 expected_arg_tys = vec![];
2955 self.err_args(args.len())
2957 ty::Tuple(arg_types) => {
2958 expected_arg_tys = match expected_arg_tys.get(0) {
2959 Some(&ty) => match ty.sty {
2960 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
2965 arg_types.iter().map(|k| k.expect_ty()).collect()
2968 span_err!(tcx.sess, sp, E0059,
2969 "cannot use call notation; the first type parameter \
2970 for the function trait is neither a tuple nor unit");
2971 expected_arg_tys = vec![];
2972 self.err_args(args.len())
2975 } else if expected_arg_count == supplied_arg_count {
2977 } else if c_variadic {
2978 if supplied_arg_count >= expected_arg_count {
2981 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
2982 expected_arg_tys = vec![];
2983 self.err_args(supplied_arg_count)
2986 // is the missing argument of type `()`?
2987 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
2988 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
2989 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
2990 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
2994 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
2996 expected_arg_tys = vec![];
2997 self.err_args(supplied_arg_count)
3000 debug!("check_argument_types: formal_tys={:?}",
3001 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3003 // If there is no expectation, expect formal_tys.
3004 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3010 // Check the arguments.
3011 // We do this in a pretty awful way: first we type-check any arguments
3012 // that are not closures, then we type-check the closures. This is so
3013 // that we have more information about the types of arguments when we
3014 // type-check the functions. This isn't really the right way to do this.
3015 for &check_closures in &[false, true] {
3016 debug!("check_closures={}", check_closures);
3018 // More awful hacks: before we check argument types, try to do
3019 // an "opportunistic" vtable resolution of any trait bounds on
3020 // the call. This helps coercions.
3022 self.select_obligations_where_possible(false);
3025 // For C-variadic functions, we don't have a declared type for all of
3026 // the arguments hence we only do our usual type checking with
3027 // the arguments who's types we do know.
3028 let t = if c_variadic {
3030 } else if tuple_arguments == TupleArguments {
3035 for (i, arg) in args.iter().take(t).enumerate() {
3036 // Warn only for the first loop (the "no closures" one).
3037 // Closure arguments themselves can't be diverging, but
3038 // a previous argument can, e.g., `foo(panic!(), || {})`.
3039 if !check_closures {
3040 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3043 let is_closure = match arg.node {
3044 ExprKind::Closure(..) => true,
3048 if is_closure != check_closures {
3052 debug!("checking the argument");
3053 let formal_ty = formal_tys[i];
3055 // The special-cased logic below has three functions:
3056 // 1. Provide as good of an expected type as possible.
3057 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3059 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3061 // 2. Coerce to the most detailed type that could be coerced
3062 // to, which is `expected_ty` if `rvalue_hint` returns an
3063 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3064 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3065 // We're processing function arguments so we definitely want to use
3066 // two-phase borrows.
3067 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3069 // 3. Relate the expected type and the formal one,
3070 // if the expected type was used for the coercion.
3071 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3075 // We also need to make sure we at least write the ty of the other
3076 // arguments which we skipped above.
3078 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3079 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3080 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3083 for arg in args.iter().skip(expected_arg_count) {
3084 let arg_ty = self.check_expr(&arg);
3086 // There are a few types which get autopromoted when passed via varargs
3087 // in C but we just error out instead and require explicit casts.
3088 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3090 ty::Float(ast::FloatTy::F32) => {
3091 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3093 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3094 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3096 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3097 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3100 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3101 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3102 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3110 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3111 vec![self.tcx.types.err; len]
3114 // AST fragment checking
3117 expected: Expectation<'tcx>)
3123 ast::LitKind::Str(..) => tcx.mk_static_str(),
3124 ast::LitKind::ByteStr(ref v) => {
3125 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3126 tcx.mk_array(tcx.types.u8, v.len() as u64))
3128 ast::LitKind::Byte(_) => tcx.types.u8,
3129 ast::LitKind::Char(_) => tcx.types.char,
3130 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3131 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3132 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3133 let opt_ty = expected.to_option(self).and_then(|ty| {
3135 ty::Int(_) | ty::Uint(_) => Some(ty),
3136 ty::Char => Some(tcx.types.u8),
3137 ty::RawPtr(..) => Some(tcx.types.usize),
3138 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3142 opt_ty.unwrap_or_else(|| self.next_int_var())
3144 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3145 ast::LitKind::FloatUnsuffixed(_) => {
3146 let opt_ty = expected.to_option(self).and_then(|ty| {
3148 ty::Float(_) => Some(ty),
3152 opt_ty.unwrap_or_else(|| self.next_float_var())
3154 ast::LitKind::Bool(_) => tcx.types.bool,
3155 ast::LitKind::Err(_) => tcx.types.err,
3159 fn check_expr_eq_type(&self,
3160 expr: &'gcx hir::Expr,
3161 expected: Ty<'tcx>) {
3162 let ty = self.check_expr_with_hint(expr, expected);
3163 self.demand_eqtype(expr.span, expected, ty);
3166 pub fn check_expr_has_type_or_error(&self,
3167 expr: &'gcx hir::Expr,
3168 expected: Ty<'tcx>) -> Ty<'tcx> {
3169 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3172 fn check_expr_meets_expectation_or_error(&self,
3173 expr: &'gcx hir::Expr,
3174 expected: Expectation<'tcx>) -> Ty<'tcx> {
3175 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3176 let mut ty = self.check_expr_with_expectation(expr, expected);
3178 // While we don't allow *arbitrary* coercions here, we *do* allow
3179 // coercions from ! to `expected`.
3181 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3182 "expression with never type wound up being adjusted");
3183 let adj_ty = self.next_diverging_ty_var(
3184 TypeVariableOrigin {
3185 kind: TypeVariableOriginKind::AdjustmentType,
3189 self.apply_adjustments(expr, vec![Adjustment {
3190 kind: Adjust::NeverToAny,
3196 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3197 let expr = match &expr.node {
3198 ExprKind::DropTemps(expr) => expr,
3201 // Error possibly reported in `check_assign` so avoid emitting error again.
3202 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3207 fn check_expr_coercable_to_type(&self,
3208 expr: &'gcx hir::Expr,
3209 expected: Ty<'tcx>) -> Ty<'tcx> {
3210 let ty = self.check_expr_with_hint(expr, expected);
3211 // checks don't need two phase
3212 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3215 fn check_expr_with_hint(&self,
3216 expr: &'gcx hir::Expr,
3217 expected: Ty<'tcx>) -> Ty<'tcx> {
3218 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3221 fn check_expr_with_expectation(&self,
3222 expr: &'gcx hir::Expr,
3223 expected: Expectation<'tcx>) -> Ty<'tcx> {
3224 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3227 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3228 self.check_expr_with_expectation(expr, NoExpectation)
3231 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3232 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3235 // Determine the `Self` type, using fresh variables for all variables
3236 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3237 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3239 pub fn impl_self_ty(&self,
3240 span: Span, // (potential) receiver for this impl
3242 -> TypeAndSubsts<'tcx> {
3243 let ity = self.tcx.type_of(did);
3244 debug!("impl_self_ty: ity={:?}", ity);
3246 let substs = self.fresh_substs_for_item(span, did);
3247 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3249 TypeAndSubsts { substs: substs, ty: substd_ty }
3252 /// Unifies the output type with the expected type early, for more coercions
3253 /// and forward type information on the input expressions.
3254 fn expected_inputs_for_expected_output(&self,
3256 expected_ret: Expectation<'tcx>,
3257 formal_ret: Ty<'tcx>,
3258 formal_args: &[Ty<'tcx>])
3260 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3261 let ret_ty = match expected_ret.only_has_type(self) {
3263 None => return Vec::new()
3265 let expect_args = self.fudge_inference_if_ok(|| {
3266 // Attempt to apply a subtyping relationship between the formal
3267 // return type (likely containing type variables if the function
3268 // is polymorphic) and the expected return type.
3269 // No argument expectations are produced if unification fails.
3270 let origin = self.misc(call_span);
3271 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3273 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3274 // to identity so the resulting type is not constrained.
3277 // Process any obligations locally as much as
3278 // we can. We don't care if some things turn
3279 // out unconstrained or ambiguous, as we're
3280 // just trying to get hints here.
3281 self.save_and_restore_in_snapshot_flag(|_| {
3282 let mut fulfill = TraitEngine::new(self.tcx);
3283 for obligation in ok.obligations {
3284 fulfill.register_predicate_obligation(self, obligation);
3286 fulfill.select_where_possible(self)
3287 }).map_err(|_| ())?;
3289 Err(_) => return Err(()),
3292 // Record all the argument types, with the substitutions
3293 // produced from the above subtyping unification.
3294 Ok(formal_args.iter().map(|ty| {
3295 self.resolve_vars_if_possible(ty)
3297 }).unwrap_or_default();
3298 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3299 formal_args, formal_ret,
3300 expect_args, expected_ret);
3304 // Checks a method call.
3305 fn check_method_call(&self,
3306 expr: &'gcx hir::Expr,
3307 segment: &hir::PathSegment,
3309 args: &'gcx [hir::Expr],
3310 expected: Expectation<'tcx>,
3311 needs: Needs) -> Ty<'tcx> {
3312 let rcvr = &args[0];
3313 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3314 // no need to check for bot/err -- callee does that
3315 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3317 let method = match self.lookup_method(rcvr_t,
3323 self.write_method_call(expr.hir_id, method);
3327 if segment.ident.name != kw::Invalid {
3328 self.report_method_error(span,
3331 SelfSource::MethodCall(rcvr),
3339 // Call the generic checker.
3340 self.check_method_argument_types(span,
3348 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3352 .unwrap_or_else(|| span_bug!(return_expr.span,
3353 "check_return_expr called outside fn body"));
3355 let ret_ty = ret_coercion.borrow().expected_ty();
3356 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3357 ret_coercion.borrow_mut()
3359 &self.cause(return_expr.span,
3360 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3365 // Check field access expressions
3366 fn check_field(&self,
3367 expr: &'gcx hir::Expr,
3369 base: &'gcx hir::Expr,
3370 field: ast::Ident) -> Ty<'tcx> {
3371 let expr_t = self.check_expr_with_needs(base, needs);
3372 let expr_t = self.structurally_resolved_type(base.span,
3374 let mut private_candidate = None;
3375 let mut autoderef = self.autoderef(expr.span, expr_t);
3376 while let Some((base_t, _)) = autoderef.next() {
3378 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3379 debug!("struct named {:?}", base_t);
3380 let (ident, def_scope) =
3381 self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
3382 let fields = &base_def.non_enum_variant().fields;
3383 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3384 let field = &fields[index];
3385 let field_ty = self.field_ty(expr.span, field, substs);
3386 // Save the index of all fields regardless of their visibility in case
3387 // of error recovery.
3388 self.write_field_index(expr.hir_id, index);
3389 if field.vis.is_accessible_from(def_scope, self.tcx) {
3390 let adjustments = autoderef.adjust_steps(self, needs);
3391 self.apply_adjustments(base, adjustments);
3392 autoderef.finalize(self);
3394 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3397 private_candidate = Some((base_def.did, field_ty));
3400 ty::Tuple(ref tys) => {
3401 let fstr = field.as_str();
3402 if let Ok(index) = fstr.parse::<usize>() {
3403 if fstr == index.to_string() {
3404 if let Some(field_ty) = tys.get(index) {
3405 let adjustments = autoderef.adjust_steps(self, needs);
3406 self.apply_adjustments(base, adjustments);
3407 autoderef.finalize(self);
3409 self.write_field_index(expr.hir_id, index);
3410 return field_ty.expect_ty();
3418 autoderef.unambiguous_final_ty(self);
3420 if let Some((did, field_ty)) = private_candidate {
3421 let struct_path = self.tcx().def_path_str(did);
3422 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3423 "field `{}` of struct `{}` is private",
3424 field, struct_path);
3425 // Also check if an accessible method exists, which is often what is meant.
3426 if self.method_exists(field, expr_t, expr.hir_id, false)
3427 && !self.expr_in_place(expr.hir_id)
3429 self.suggest_method_call(
3431 &format!("a method `{}` also exists, call it with parentheses", field),
3439 } else if field.name == kw::Invalid {
3440 self.tcx().types.err
3441 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3442 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3443 "attempted to take value of method `{}` on type `{}`",
3446 if !self.expr_in_place(expr.hir_id) {
3447 self.suggest_method_call(
3449 "use parentheses to call the method",
3455 err.help("methods are immutable and cannot be assigned to");
3459 self.tcx().types.err
3461 if !expr_t.is_primitive_ty() {
3462 let mut err = self.no_such_field_err(field.span, field, expr_t);
3465 ty::Adt(def, _) if !def.is_enum() => {
3466 if let Some(suggested_field_name) =
3467 Self::suggest_field_name(def.non_enum_variant(),
3468 &field.as_str(), vec![]) {
3469 err.span_suggestion(
3471 "a field with a similar name exists",
3472 suggested_field_name.to_string(),
3473 Applicability::MaybeIncorrect,
3476 err.span_label(field.span, "unknown field");
3477 let struct_variant_def = def.non_enum_variant();
3478 let field_names = self.available_field_names(struct_variant_def);
3479 if !field_names.is_empty() {
3480 err.note(&format!("available fields are: {}",
3481 self.name_series_display(field_names)));
3485 ty::Array(_, len) => {
3486 if let (Some(len), Ok(user_index)) = (
3487 len.assert_usize(self.tcx),
3488 field.as_str().parse::<u64>()
3490 let base = self.tcx.sess.source_map()
3491 .span_to_snippet(base.span)
3493 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3494 let help = "instead of using tuple indexing, use array indexing";
3495 let suggestion = format!("{}[{}]", base, field);
3496 let applicability = if len < user_index {
3497 Applicability::MachineApplicable
3499 Applicability::MaybeIncorrect
3501 err.span_suggestion(
3502 expr.span, help, suggestion, applicability
3507 let base = self.tcx.sess.source_map()
3508 .span_to_snippet(base.span)
3509 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3510 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3511 let suggestion = format!("(*{}).{}", base, field);
3512 err.span_suggestion(
3516 Applicability::MaybeIncorrect,
3523 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3524 "`{}` is a primitive type and therefore doesn't have fields",
3527 self.tcx().types.err
3531 // Return an hint about the closest match in field names
3532 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3534 skip: Vec<LocalInternedString>)
3536 let names = variant.fields.iter().filter_map(|field| {
3537 // ignore already set fields and private fields from non-local crates
3538 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3539 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3543 Some(&field.ident.name)
3547 find_best_match_for_name(names, field, None)
3550 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3551 variant.fields.iter().filter(|field| {
3553 self.tcx.adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id).1;
3554 field.vis.is_accessible_from(def_scope, self.tcx)
3556 .map(|field| field.ident.name)
3560 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3561 // dynamic limit, to never omit just one field
3562 let limit = if names.len() == 6 { 6 } else { 5 };
3563 let mut display = names.iter().take(limit)
3564 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3565 if names.len() > limit {
3566 display = format!("{} ... and {} others", display, names.len() - limit);
3571 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3572 -> DiagnosticBuilder<'_> {
3573 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3574 "no field `{}` on type `{}`",
3578 fn report_unknown_field(
3581 variant: &'tcx ty::VariantDef,
3583 skip_fields: &[hir::Field],
3586 if variant.recovered {
3589 let mut err = self.type_error_struct_with_diag(
3591 |actual| match ty.sty {
3592 ty::Adt(adt, ..) if adt.is_enum() => {
3593 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3594 "{} `{}::{}` has no field named `{}`",
3595 kind_name, actual, variant.ident, field.ident)
3598 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3599 "{} `{}` has no field named `{}`",
3600 kind_name, actual, field.ident)
3604 // prevent all specified fields from being suggested
3605 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3606 if let Some(field_name) = Self::suggest_field_name(variant,
3607 &field.ident.as_str(),
3608 skip_fields.collect()) {
3609 err.span_suggestion(
3611 "a field with a similar name exists",
3612 field_name.to_string(),
3613 Applicability::MaybeIncorrect,
3617 ty::Adt(adt, ..) => {
3619 err.span_label(field.ident.span,
3620 format!("`{}::{}` does not have this field",
3621 ty, variant.ident));
3623 err.span_label(field.ident.span,
3624 format!("`{}` does not have this field", ty));
3626 let available_field_names = self.available_field_names(variant);
3627 if !available_field_names.is_empty() {
3628 err.note(&format!("available fields are: {}",
3629 self.name_series_display(available_field_names)));
3632 _ => bug!("non-ADT passed to report_unknown_field")
3638 fn check_expr_struct_fields(&self,
3640 expected: Expectation<'tcx>,
3641 expr_id: hir::HirId,
3643 variant: &'tcx ty::VariantDef,
3644 ast_fields: &'gcx [hir::Field],
3645 check_completeness: bool) -> bool {
3649 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3650 .get(0).cloned().unwrap_or(adt_ty);
3651 // re-link the regions that EIfEO can erase.
3652 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3654 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3655 &ty::Adt(adt, substs) => {
3656 (substs, adt.adt_kind(), adt.variant_descr())
3658 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3661 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3662 (field.ident.modern(), (i, field))
3663 ).collect::<FxHashMap<_, _>>();
3665 let mut seen_fields = FxHashMap::default();
3667 let mut error_happened = false;
3669 // Type-check each field.
3670 for field in ast_fields {
3671 let ident = tcx.adjust_ident(field.ident, variant.def_id);
3672 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3673 seen_fields.insert(ident, field.span);
3674 self.write_field_index(field.hir_id, i);
3676 // We don't look at stability attributes on
3677 // struct-like enums (yet...), but it's definitely not
3678 // a bug to have constructed one.
3679 if adt_kind != AdtKind::Enum {
3680 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3683 self.field_ty(field.span, v_field, substs)
3685 error_happened = true;
3686 if let Some(prev_span) = seen_fields.get(&ident) {
3687 let mut err = struct_span_err!(self.tcx.sess,
3690 "field `{}` specified more than once",
3693 err.span_label(field.ident.span, "used more than once");
3694 err.span_label(*prev_span, format!("first use of `{}`", ident));
3698 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3704 // Make sure to give a type to the field even if there's
3705 // an error, so we can continue type-checking.
3706 self.check_expr_coercable_to_type(&field.expr, field_type);
3709 // Make sure the programmer specified correct number of fields.
3710 if kind_name == "union" {
3711 if ast_fields.len() != 1 {
3712 tcx.sess.span_err(span, "union expressions should have exactly one field");
3714 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3715 let len = remaining_fields.len();
3717 let mut displayable_field_names = remaining_fields
3719 .map(|ident| ident.as_str())
3720 .collect::<Vec<_>>();
3722 displayable_field_names.sort();
3724 let truncated_fields_error = if len <= 3 {
3727 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3730 let remaining_fields_names = displayable_field_names.iter().take(3)
3731 .map(|n| format!("`{}`", n))
3732 .collect::<Vec<_>>()
3735 struct_span_err!(tcx.sess, span, E0063,
3736 "missing field{} {}{} in initializer of `{}`",
3737 if remaining_fields.len() == 1 { "" } else { "s" },
3738 remaining_fields_names,
3739 truncated_fields_error,
3741 .span_label(span, format!("missing {}{}",
3742 remaining_fields_names,
3743 truncated_fields_error))
3749 fn check_struct_fields_on_error(&self,
3750 fields: &'gcx [hir::Field],
3751 base_expr: &'gcx Option<P<hir::Expr>>) {
3752 for field in fields {
3753 self.check_expr(&field.expr);
3755 if let Some(ref base) = *base_expr {
3756 self.check_expr(&base);
3760 pub fn check_struct_path(&self,
3763 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3764 let path_span = match *qpath {
3765 QPath::Resolved(_, ref path) => path.span,
3766 QPath::TypeRelative(ref qself, _) => qself.span
3768 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3769 let variant = match def {
3771 self.set_tainted_by_errors();
3774 Res::Def(DefKind::Variant, _) => {
3776 ty::Adt(adt, substs) => {
3777 Some((adt.variant_of_res(def), adt.did, substs))
3779 _ => bug!("unexpected type: {:?}", ty)
3782 Res::Def(DefKind::Struct, _)
3783 | Res::Def(DefKind::Union, _)
3784 | Res::Def(DefKind::TyAlias, _)
3785 | Res::Def(DefKind::AssocTy, _)
3786 | Res::SelfTy(..) => {
3788 ty::Adt(adt, substs) if !adt.is_enum() => {
3789 Some((adt.non_enum_variant(), adt.did, substs))
3794 _ => bug!("unexpected definition: {:?}", def)
3797 if let Some((variant, did, substs)) = variant {
3798 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3799 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3801 // Check bounds on type arguments used in the path.
3802 let bounds = self.instantiate_bounds(path_span, did, substs);
3803 let cause = traits::ObligationCause::new(path_span, self.body_id,
3804 traits::ItemObligation(did));
3805 self.add_obligations_for_parameters(cause, &bounds);
3809 struct_span_err!(self.tcx.sess, path_span, E0071,
3810 "expected struct, variant or union type, found {}",
3811 ty.sort_string(self.tcx))
3812 .span_label(path_span, "not a struct")
3818 fn check_expr_struct(&self,
3820 expected: Expectation<'tcx>,
3822 fields: &'gcx [hir::Field],
3823 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3825 // Find the relevant variant
3826 let (variant, adt_ty) =
3827 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3830 self.check_struct_fields_on_error(fields, base_expr);
3831 return self.tcx.types.err;
3834 let path_span = match *qpath {
3835 QPath::Resolved(_, ref path) => path.span,
3836 QPath::TypeRelative(ref qself, _) => qself.span
3839 // Prohibit struct expressions when non-exhaustive flag is set.
3840 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3841 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3842 span_err!(self.tcx.sess, expr.span, E0639,
3843 "cannot create non-exhaustive {} using struct expression",
3844 adt.variant_descr());
3847 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3848 variant, fields, base_expr.is_none());
3849 if let &Some(ref base_expr) = base_expr {
3850 // If check_expr_struct_fields hit an error, do not attempt to populate
3851 // the fields with the base_expr. This could cause us to hit errors later
3852 // when certain fields are assumed to exist that in fact do not.
3853 if !error_happened {
3854 self.check_expr_has_type_or_error(base_expr, adt_ty);
3856 ty::Adt(adt, substs) if adt.is_struct() => {
3857 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3858 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3863 .fru_field_types_mut()
3864 .insert(expr.hir_id, fru_field_types);
3867 span_err!(self.tcx.sess, base_expr.span, E0436,
3868 "functional record update syntax requires a struct");
3873 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3879 /// If an expression has any sub-expressions that result in a type error,
3880 /// inspecting that expression's type with `ty.references_error()` will return
3881 /// true. Likewise, if an expression is known to diverge, inspecting its
3882 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3883 /// strict, _|_ can appear in the type of an expression that does not,
3884 /// itself, diverge: for example, fn() -> _|_.)
3885 /// Note that inspecting a type's structure *directly* may expose the fact
3886 /// that there are actually multiple representations for `Error`, so avoid
3887 /// that when err needs to be handled differently.
3888 fn check_expr_with_expectation_and_needs(&self,
3889 expr: &'gcx hir::Expr,
3890 expected: Expectation<'tcx>,
3891 needs: Needs) -> Ty<'tcx> {
3892 debug!(">> type-checking: expr={:?} expected={:?}",
3895 // Warn for expressions after diverging siblings.
3896 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3898 // Hide the outer diverging and has_errors flags.
3899 let old_diverges = self.diverges.get();
3900 let old_has_errors = self.has_errors.get();
3901 self.diverges.set(Diverges::Maybe);
3902 self.has_errors.set(false);
3904 let ty = self.check_expr_kind(expr, expected, needs);
3906 // Warn for non-block expressions with diverging children.
3908 ExprKind::Block(..) |
3909 ExprKind::Loop(..) | ExprKind::While(..) |
3910 ExprKind::Match(..) => {}
3912 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3915 // Any expression that produces a value of type `!` must have diverged
3917 self.diverges.set(self.diverges.get() | Diverges::Always);
3920 // Record the type, which applies it effects.
3921 // We need to do this after the warning above, so that
3922 // we don't warn for the diverging expression itself.
3923 self.write_ty(expr.hir_id, ty);
3925 // Combine the diverging and has_error flags.
3926 self.diverges.set(self.diverges.get() | old_diverges);
3927 self.has_errors.set(self.has_errors.get() | old_has_errors);
3929 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3930 debug!("... {:?}, expected is {:?}", ty, expected);
3937 expr: &'gcx hir::Expr,
3938 expected: Expectation<'tcx>,
3942 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3949 let id = expr.hir_id;
3951 ExprKind::Box(ref subexpr) => {
3952 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3954 ty::Adt(def, _) if def.is_box()
3955 => Expectation::rvalue_hint(self, ty.boxed_ty()),
3959 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
3960 tcx.mk_box(referent_ty)
3963 ExprKind::Lit(ref lit) => {
3964 self.check_lit(&lit, expected)
3966 ExprKind::Binary(op, ref lhs, ref rhs) => {
3967 self.check_binop(expr, op, lhs, rhs)
3969 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
3970 self.check_binop_assign(expr, op, lhs, rhs)
3972 ExprKind::Unary(unop, ref oprnd) => {
3973 let expected_inner = match unop {
3974 hir::UnNot | hir::UnNeg => {
3981 let needs = match unop {
3982 hir::UnDeref => needs,
3985 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
3989 if !oprnd_t.references_error() {
3990 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
3993 if let Some(mt) = oprnd_t.builtin_deref(true) {
3995 } else if let Some(ok) = self.try_overloaded_deref(
3996 expr.span, oprnd_t, needs) {
3997 let method = self.register_infer_ok_obligations(ok);
3998 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
3999 let mutbl = match mutbl {
4000 hir::MutImmutable => AutoBorrowMutability::Immutable,
4001 hir::MutMutable => AutoBorrowMutability::Mutable {
4002 // (It shouldn't actually matter for unary ops whether
4003 // we enable two-phase borrows or not, since a unary
4004 // op has no additional operands.)
4005 allow_two_phase_borrow: AllowTwoPhase::No,
4008 self.apply_adjustments(oprnd, vec![Adjustment {
4009 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4010 target: method.sig.inputs()[0]
4013 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4014 self.write_method_call(expr.hir_id, method);
4016 let mut err = type_error_struct!(
4021 "type `{}` cannot be dereferenced",
4024 let sp = tcx.sess.source_map().start_point(expr.span);
4025 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
4028 tcx.sess.parse_sess.expr_parentheses_needed(
4035 oprnd_t = tcx.types.err;
4039 let result = self.check_user_unop(expr, oprnd_t, unop);
4040 // If it's builtin, we can reuse the type, this helps inference.
4041 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4046 let result = self.check_user_unop(expr, oprnd_t, unop);
4047 // If it's builtin, we can reuse the type, this helps inference.
4048 if !(oprnd_t.is_integral() || oprnd_t.is_fp()) {
4056 ExprKind::AddrOf(mutbl, ref oprnd) => {
4057 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4059 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4060 if oprnd.is_place_expr() {
4061 // Places may legitimately have unsized types.
4062 // For example, dereferences of a fat pointer and
4063 // the last field of a struct can be unsized.
4066 Expectation::rvalue_hint(self, ty)
4072 let needs = Needs::maybe_mut_place(mutbl);
4073 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4075 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4076 if tm.ty.references_error() {
4079 // Note: at this point, we cannot say what the best lifetime
4080 // is to use for resulting pointer. We want to use the
4081 // shortest lifetime possible so as to avoid spurious borrowck
4082 // errors. Moreover, the longest lifetime will depend on the
4083 // precise details of the value whose address is being taken
4084 // (and how long it is valid), which we don't know yet until type
4085 // inference is complete.
4087 // Therefore, here we simply generate a region variable. The
4088 // region inferencer will then select the ultimate value.
4089 // Finally, borrowck is charged with guaranteeing that the
4090 // value whose address was taken can actually be made to live
4091 // as long as it needs to live.
4092 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4093 tcx.mk_ref(region, tm)
4096 ExprKind::Path(ref qpath) => {
4097 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4099 let ty = match res {
4101 self.set_tainted_by_errors();
4104 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4105 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4108 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4111 if let ty::FnDef(..) = ty.sty {
4112 let fn_sig = ty.fn_sig(tcx);
4113 if !tcx.features().unsized_locals {
4114 // We want to remove some Sized bounds from std functions,
4115 // but don't want to expose the removal to stable Rust.
4116 // i.e., we don't want to allow
4122 // to work in stable even if the Sized bound on `drop` is relaxed.
4123 for i in 0..fn_sig.inputs().skip_binder().len() {
4124 // We just want to check sizedness, so instead of introducing
4125 // placeholder lifetimes with probing, we just replace higher lifetimes
4127 let input = self.replace_bound_vars_with_fresh_vars(
4129 infer::LateBoundRegionConversionTime::FnCall,
4130 &fn_sig.input(i)).0;
4131 self.require_type_is_sized_deferred(input, expr.span,
4132 traits::SizedArgumentType);
4135 // Here we want to prevent struct constructors from returning unsized types.
4136 // There were two cases this happened: fn pointer coercion in stable
4137 // and usual function call in presense of unsized_locals.
4138 // Also, as we just want to check sizedness, instead of introducing
4139 // placeholder lifetimes with probing, we just replace higher lifetimes
4141 let output = self.replace_bound_vars_with_fresh_vars(
4143 infer::LateBoundRegionConversionTime::FnCall,
4144 &fn_sig.output()).0;
4145 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4148 // We always require that the type provided as the value for
4149 // a type parameter outlives the moment of instantiation.
4150 let substs = self.tables.borrow().node_substs(expr.hir_id);
4151 self.add_wf_bounds(substs, expr);
4155 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4156 for expr in outputs.iter().chain(inputs.iter()) {
4157 self.check_expr(expr);
4161 ExprKind::Break(destination, ref expr_opt) => {
4162 if let Ok(target_id) = destination.target_id {
4164 if let Some(ref e) = *expr_opt {
4165 // If this is a break with a value, we need to type-check
4166 // the expression. Get an expected type from the loop context.
4167 let opt_coerce_to = {
4168 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4169 enclosing_breakables.find_breakable(target_id)
4172 .map(|coerce| coerce.expected_ty())
4175 // If the loop context is not a `loop { }`, then break with
4176 // a value is illegal, and `opt_coerce_to` will be `None`.
4177 // Just set expectation to error in that case.
4178 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4180 // Recurse without `enclosing_breakables` borrowed.
4181 e_ty = self.check_expr_with_hint(e, coerce_to);
4182 cause = self.misc(e.span);
4184 // Otherwise, this is a break *without* a value. That's
4185 // always legal, and is equivalent to `break ()`.
4186 e_ty = tcx.mk_unit();
4187 cause = self.misc(expr.span);
4190 // Now that we have type-checked `expr_opt`, borrow
4191 // the `enclosing_loops` field and let's coerce the
4192 // type of `expr_opt` into what is expected.
4193 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4194 let ctxt = enclosing_breakables.find_breakable(target_id);
4195 if let Some(ref mut coerce) = ctxt.coerce {
4196 if let Some(ref e) = *expr_opt {
4197 coerce.coerce(self, &cause, e, e_ty);
4199 assert!(e_ty.is_unit());
4200 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4203 // If `ctxt.coerce` is `None`, we can just ignore
4204 // the type of the expresison. This is because
4205 // either this was a break *without* a value, in
4206 // which case it is always a legal type (`()`), or
4207 // else an error would have been flagged by the
4208 // `loops` pass for using break with an expression
4209 // where you are not supposed to.
4210 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4213 ctxt.may_break = true;
4215 // the type of a `break` is always `!`, since it diverges
4218 // Otherwise, we failed to find the enclosing loop;
4219 // this can only happen if the `break` was not
4220 // inside a loop at all, which is caught by the
4221 // loop-checking pass.
4222 if self.tcx.sess.err_count() == 0 {
4223 self.tcx.sess.delay_span_bug(expr.span,
4224 "break was outside loop, but no error was emitted");
4227 // We still need to assign a type to the inner expression to
4228 // prevent the ICE in #43162.
4229 if let Some(ref e) = *expr_opt {
4230 self.check_expr_with_hint(e, tcx.types.err);
4232 // ... except when we try to 'break rust;'.
4233 // ICE this expression in particular (see #43162).
4234 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4235 if path.segments.len() == 1 &&
4236 path.segments[0].ident.name == sym::rust {
4237 fatally_break_rust(self.tcx.sess);
4241 // There was an error; make type-check fail.
4246 ExprKind::Continue(destination) => {
4247 if destination.target_id.is_ok() {
4250 // There was an error; make type-check fail.
4254 ExprKind::Ret(ref expr_opt) => {
4255 if self.ret_coercion.is_none() {
4256 struct_span_err!(self.tcx.sess, expr.span, E0572,
4257 "return statement outside of function body").emit();
4258 } else if let Some(ref e) = *expr_opt {
4259 if self.ret_coercion_span.borrow().is_none() {
4260 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4262 self.check_return_expr(e);
4264 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4265 if self.ret_coercion_span.borrow().is_none() {
4266 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4268 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4269 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4270 coercion.coerce_forced_unit(
4275 fn_decl.output.span(),
4277 "expected `{}` because of this return type",
4285 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4290 ExprKind::Assign(ref lhs, ref rhs) => {
4291 self.check_assign(expr, expected, lhs, rhs)
4293 ExprKind::While(ref cond, ref body, _) => {
4294 let ctxt = BreakableCtxt {
4295 // cannot use break with a value from a while loop
4297 may_break: false, // Will get updated if/when we find a `break`.
4300 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4301 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4302 let cond_diverging = self.diverges.get();
4303 self.check_block_no_value(&body);
4305 // We may never reach the body so it diverging means nothing.
4306 self.diverges.set(cond_diverging);
4310 // No way to know whether it's diverging because
4311 // of a `break` or an outer `break` or `return`.
4312 self.diverges.set(Diverges::Maybe);
4317 ExprKind::Loop(ref body, _, source) => {
4318 let coerce = match source {
4319 // you can only use break with a value from a normal `loop { }`
4320 hir::LoopSource::Loop => {
4321 let coerce_to = expected.coercion_target_type(self, body.span);
4322 Some(CoerceMany::new(coerce_to))
4325 hir::LoopSource::WhileLet |
4326 hir::LoopSource::ForLoop => {
4331 let ctxt = BreakableCtxt {
4333 may_break: false, // Will get updated if/when we find a `break`.
4336 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4337 self.check_block_no_value(&body);
4341 // No way to know whether it's diverging because
4342 // of a `break` or an outer `break` or `return`.
4343 self.diverges.set(Diverges::Maybe);
4346 // If we permit break with a value, then result type is
4347 // the LUB of the breaks (possibly ! if none); else, it
4348 // is nil. This makes sense because infinite loops
4349 // (which would have type !) are only possible iff we
4350 // permit break with a value [1].
4351 if ctxt.coerce.is_none() && !ctxt.may_break {
4353 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4355 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4357 ExprKind::Match(ref discrim, ref arms, match_src) => {
4358 self.check_match(expr, &discrim, arms, expected, match_src)
4360 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4361 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4363 ExprKind::Block(ref body, _) => {
4364 self.check_block_with_expected(&body, expected)
4366 ExprKind::Call(ref callee, ref args) => {
4367 self.check_call(expr, &callee, args, expected)
4369 ExprKind::MethodCall(ref segment, span, ref args) => {
4370 self.check_method_call(expr, segment, span, args, expected, needs)
4372 ExprKind::Cast(ref e, ref t) => {
4373 // Find the type of `e`. Supply hints based on the type we are casting to,
4375 let t_cast = self.to_ty_saving_user_provided_ty(t);
4376 let t_cast = self.resolve_vars_if_possible(&t_cast);
4377 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4378 let t_cast = self.resolve_vars_if_possible(&t_cast);
4380 // Eagerly check for some obvious errors.
4381 if t_expr.references_error() || t_cast.references_error() {
4384 // Defer other checks until we're done type checking.
4385 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4386 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4388 deferred_cast_checks.push(cast_check);
4391 Err(ErrorReported) => {
4397 ExprKind::Type(ref e, ref t) => {
4398 let ty = self.to_ty_saving_user_provided_ty(&t);
4399 self.check_expr_eq_type(&e, ty);
4402 ExprKind::DropTemps(ref e) => {
4403 self.check_expr_with_expectation(e, expected)
4405 ExprKind::Array(ref args) => {
4406 let uty = expected.to_option(self).and_then(|uty| {
4408 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4413 let element_ty = if !args.is_empty() {
4414 let coerce_to = uty.unwrap_or_else(|| {
4415 self.next_ty_var(TypeVariableOrigin {
4416 kind: TypeVariableOriginKind::TypeInference,
4420 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4421 assert_eq!(self.diverges.get(), Diverges::Maybe);
4423 let e_ty = self.check_expr_with_hint(e, coerce_to);
4424 let cause = self.misc(e.span);
4425 coerce.coerce(self, &cause, e, e_ty);
4427 coerce.complete(self)
4429 self.next_ty_var(TypeVariableOrigin {
4430 kind: TypeVariableOriginKind::TypeInference,
4434 tcx.mk_array(element_ty, args.len() as u64)
4436 ExprKind::Repeat(ref element, ref count) => {
4437 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4438 let param_env = ty::ParamEnv::empty();
4439 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4440 let instance = ty::Instance::resolve(
4446 let global_id = GlobalId {
4450 let count = tcx.const_eval(param_env.and(global_id));
4452 let uty = match expected {
4453 ExpectHasType(uty) => {
4455 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4462 let (element_ty, t) = match uty {
4464 self.check_expr_coercable_to_type(&element, uty);
4468 let ty = self.next_ty_var(TypeVariableOrigin {
4469 kind: TypeVariableOriginKind::MiscVariable,
4472 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4477 if let Ok(count) = count {
4478 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4480 // For [foo, ..n] where n > 1, `foo` must have
4482 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4483 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4487 if element_ty.references_error() {
4489 } else if let Ok(count) = count {
4490 tcx.mk_ty(ty::Array(t, count))
4495 ExprKind::Tup(ref elts) => {
4496 let flds = expected.only_has_type(self).and_then(|ty| {
4497 let ty = self.resolve_type_vars_with_obligations(ty);
4499 ty::Tuple(ref flds) => Some(&flds[..]),
4504 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4505 let t = match flds {
4506 Some(ref fs) if i < fs.len() => {
4507 let ety = fs[i].expect_ty();
4508 self.check_expr_coercable_to_type(&e, ety);
4512 self.check_expr_with_expectation(&e, NoExpectation)
4517 let tuple = tcx.mk_tup(elt_ts_iter);
4518 if tuple.references_error() {
4521 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4525 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4526 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4528 ExprKind::Field(ref base, field) => {
4529 self.check_field(expr, needs, &base, field)
4531 ExprKind::Index(ref base, ref idx) => {
4532 let base_t = self.check_expr_with_needs(&base, needs);
4533 let idx_t = self.check_expr(&idx);
4535 if base_t.references_error() {
4537 } else if idx_t.references_error() {
4540 let base_t = self.structurally_resolved_type(base.span, base_t);
4541 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4542 Some((index_ty, element_ty)) => {
4543 // two-phase not needed because index_ty is never mutable
4544 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4549 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4550 "cannot index into a value of type `{}`",
4552 // Try to give some advice about indexing tuples.
4553 if let ty::Tuple(..) = base_t.sty {
4554 let mut needs_note = true;
4555 // If the index is an integer, we can show the actual
4556 // fixed expression:
4557 if let ExprKind::Lit(ref lit) = idx.node {
4558 if let ast::LitKind::Int(i,
4559 ast::LitIntType::Unsuffixed) = lit.node {
4560 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4561 if let Ok(snip) = snip {
4562 err.span_suggestion(
4564 "to access tuple elements, use",
4565 format!("{}.{}", snip, i),
4566 Applicability::MachineApplicable,
4573 err.help("to access tuple elements, use tuple indexing \
4574 syntax (e.g., `tuple.0`)");
4583 ExprKind::Yield(ref value) => {
4584 match self.yield_ty {
4586 self.check_expr_coercable_to_type(&value, ty);
4589 struct_span_err!(self.tcx.sess, expr.span, E0627,
4590 "yield statement outside of generator literal").emit();
4595 hir::ExprKind::Err => {
4601 /// Type check assignment expression `expr` of form `lhs = rhs`.
4602 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4605 expr: &'gcx hir::Expr,
4606 expected: Expectation<'tcx>,
4607 lhs: &'gcx hir::Expr,
4608 rhs: &'gcx hir::Expr,
4610 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4611 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4613 let expected_ty = expected.coercion_target_type(self, expr.span);
4614 if expected_ty == self.tcx.types.bool {
4615 // The expected type is `bool` but this will result in `()` so we can reasonably
4616 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4617 // The likely cause of this is `if foo = bar { .. }`.
4618 let actual_ty = self.tcx.mk_unit();
4619 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4620 let msg = "try comparing for equality";
4621 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4622 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4623 if let (Ok(left), Ok(right)) = (left, right) {
4624 let help = format!("{} == {}", left, right);
4625 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4630 } else if !lhs.is_place_expr() {
4631 struct_span_err!(self.tcx.sess, expr.span, E0070,
4632 "invalid left-hand side expression")
4633 .span_label(expr.span, "left-hand of expression not valid")
4637 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4639 if lhs_ty.references_error() || rhs_ty.references_error() {
4646 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4647 // The newly resolved definition is written into `type_dependent_defs`.
4648 fn finish_resolving_struct_path(&self,
4655 QPath::Resolved(ref maybe_qself, ref path) => {
4656 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4657 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4660 QPath::TypeRelative(ref qself, ref segment) => {
4661 let ty = self.to_ty(qself);
4663 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4668 let result = AstConv::associated_path_to_ty(
4677 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4678 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4680 // Write back the new resolution.
4681 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4683 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4688 /// Resolves associated value path into a base type and associated constant or method
4689 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4690 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4694 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4696 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4697 let (ty, qself, item_segment) = match *qpath {
4698 QPath::Resolved(ref opt_qself, ref path) => {
4700 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4701 &path.segments[..]);
4703 QPath::TypeRelative(ref qself, ref segment) => {
4704 (self.to_ty(qself), qself, segment)
4707 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4708 // Return directly on cache hit. This is useful to avoid doubly reporting
4709 // errors with default match binding modes. See #44614.
4710 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4711 .unwrap_or(Res::Err);
4712 return (def, Some(ty), slice::from_ref(&**item_segment));
4714 let item_name = item_segment.ident;
4715 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4716 let result = match error {
4717 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4718 _ => Err(ErrorReported),
4720 if item_name.name != kw::Invalid {
4721 self.report_method_error(
4725 SelfSource::QPath(qself),
4733 // Write back the new resolution.
4734 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4736 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4738 slice::from_ref(&**item_segment),
4742 pub fn check_decl_initializer(&self,
4743 local: &'gcx hir::Local,
4744 init: &'gcx hir::Expr) -> Ty<'tcx>
4746 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4747 // for #42640 (default match binding modes).
4750 let ref_bindings = local.pat.contains_explicit_ref_binding();
4752 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4753 if let Some(m) = ref_bindings {
4754 // Somewhat subtle: if we have a `ref` binding in the pattern,
4755 // we want to avoid introducing coercions for the RHS. This is
4756 // both because it helps preserve sanity and, in the case of
4757 // ref mut, for soundness (issue #23116). In particular, in
4758 // the latter case, we need to be clear that the type of the
4759 // referent for the reference that results is *equal to* the
4760 // type of the place it is referencing, and not some
4761 // supertype thereof.
4762 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4763 self.demand_eqtype(init.span, local_ty, init_ty);
4766 self.check_expr_coercable_to_type(init, local_ty)
4770 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4771 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4772 self.write_ty(local.hir_id, t);
4774 if let Some(ref init) = local.init {
4775 let init_ty = self.check_decl_initializer(local, &init);
4776 if init_ty.references_error() {
4777 self.write_ty(local.hir_id, init_ty);
4781 self.check_pat_walk(
4784 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4787 let pat_ty = self.node_ty(local.pat.hir_id);
4788 if pat_ty.references_error() {
4789 self.write_ty(local.hir_id, pat_ty);
4793 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4794 // Don't do all the complex logic below for `DeclItem`.
4796 hir::StmtKind::Item(..) => return,
4797 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4800 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4802 // Hide the outer diverging and `has_errors` flags.
4803 let old_diverges = self.diverges.get();
4804 let old_has_errors = self.has_errors.get();
4805 self.diverges.set(Diverges::Maybe);
4806 self.has_errors.set(false);
4809 hir::StmtKind::Local(ref l) => {
4810 self.check_decl_local(&l);
4813 hir::StmtKind::Item(_) => {}
4814 hir::StmtKind::Expr(ref expr) => {
4815 // Check with expected type of `()`.
4816 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4818 hir::StmtKind::Semi(ref expr) => {
4819 self.check_expr(&expr);
4823 // Combine the diverging and `has_error` flags.
4824 self.diverges.set(self.diverges.get() | old_diverges);
4825 self.has_errors.set(self.has_errors.get() | old_has_errors);
4828 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4829 let unit = self.tcx.mk_unit();
4830 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4832 // if the block produces a `!` value, that can always be
4833 // (effectively) coerced to unit.
4835 self.demand_suptype(blk.span, unit, ty);
4839 fn check_block_with_expected(&self,
4840 blk: &'gcx hir::Block,
4841 expected: Expectation<'tcx>) -> Ty<'tcx> {
4843 let mut fcx_ps = self.ps.borrow_mut();
4844 let unsafety_state = fcx_ps.recurse(blk);
4845 replace(&mut *fcx_ps, unsafety_state)
4848 // In some cases, blocks have just one exit, but other blocks
4849 // can be targeted by multiple breaks. This can happen both
4850 // with labeled blocks as well as when we desugar
4851 // a `try { ... }` expression.
4855 // 'a: { if true { break 'a Err(()); } Ok(()) }
4857 // Here we would wind up with two coercions, one from
4858 // `Err(())` and the other from the tail expression
4859 // `Ok(())`. If the tail expression is omitted, that's a
4860 // "forced unit" -- unless the block diverges, in which
4861 // case we can ignore the tail expression (e.g., `'a: {
4862 // break 'a 22; }` would not force the type of the block
4864 let tail_expr = blk.expr.as_ref();
4865 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4866 let coerce = if blk.targeted_by_break {
4867 CoerceMany::new(coerce_to_ty)
4869 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4870 Some(e) => slice::from_ref(e),
4873 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4876 let prev_diverges = self.diverges.get();
4877 let ctxt = BreakableCtxt {
4878 coerce: Some(coerce),
4882 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4883 for s in &blk.stmts {
4887 // check the tail expression **without** holding the
4888 // `enclosing_breakables` lock below.
4889 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4891 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4892 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4893 let coerce = ctxt.coerce.as_mut().unwrap();
4894 if let Some(tail_expr_ty) = tail_expr_ty {
4895 let tail_expr = tail_expr.unwrap();
4896 let cause = self.cause(tail_expr.span,
4897 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4903 // Subtle: if there is no explicit tail expression,
4904 // that is typically equivalent to a tail expression
4905 // of `()` -- except if the block diverges. In that
4906 // case, there is no value supplied from the tail
4907 // expression (assuming there are no other breaks,
4908 // this implies that the type of the block will be
4911 // #41425 -- label the implicit `()` as being the
4912 // "found type" here, rather than the "expected type".
4913 if !self.diverges.get().always() {
4914 // #50009 -- Do not point at the entire fn block span, point at the return type
4915 // span, as it is the cause of the requirement, and
4916 // `consider_hint_about_removing_semicolon` will point at the last expression
4917 // if it were a relevant part of the error. This improves usability in editors
4918 // that highlight errors inline.
4919 let mut sp = blk.span;
4920 let mut fn_span = None;
4921 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4922 let ret_sp = decl.output.span();
4923 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4924 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4925 // output would otherwise be incorrect and even misleading. Make sure
4926 // the span we're aiming at correspond to a `fn` body.
4927 if block_sp == blk.span {
4929 fn_span = Some(ident.span);
4933 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4934 if let Some(expected_ty) = expected.only_has_type(self) {
4935 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4937 if let Some(fn_span) = fn_span {
4938 err.span_label(fn_span, "this function's body doesn't return");
4946 // If we can break from the block, then the block's exit is always reachable
4947 // (... as long as the entry is reachable) - regardless of the tail of the block.
4948 self.diverges.set(prev_diverges);
4951 let mut ty = ctxt.coerce.unwrap().complete(self);
4953 if self.has_errors.get() || ty.references_error() {
4954 ty = self.tcx.types.err
4957 self.write_ty(blk.hir_id, ty);
4959 *self.ps.borrow_mut() = prev;
4963 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4964 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
4966 Node::Item(&hir::Item {
4967 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4969 Node::ImplItem(&hir::ImplItem {
4970 node: hir::ImplItemKind::Method(_, body_id), ..
4972 let body = self.tcx.hir().body(body_id);
4973 if let ExprKind::Block(block, _) = &body.value.node {
4974 return Some(block.span);
4982 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4983 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
4984 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
4985 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4988 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4989 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
4991 Node::Item(&hir::Item {
4992 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4993 }) => decl.clone().and_then(|decl| {
4994 // This is less than ideal, it will not suggest a return type span on any
4995 // method called `main`, regardless of whether it is actually the entry point,
4996 // but it will still present it as the reason for the expected type.
4997 Some((decl, ident, ident.name != sym::main))
4999 Node::TraitItem(&hir::TraitItem {
5000 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5003 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5004 Node::ImplItem(&hir::ImplItem {
5005 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5008 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5013 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
5014 /// suggestion can be made, `None` otherwise.
5015 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
5016 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5017 // `while` before reaching it, as block tail returns are not available in them.
5018 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5019 let parent = self.tcx.hir().get_by_hir_id(blk_id);
5020 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5024 /// On implicit return expressions with mismatched types, provides the following suggestions:
5026 /// - Points out the method's return type as the reason for the expected type.
5027 /// - Possible missing semicolon.
5028 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5029 pub fn suggest_mismatched_types_on_tail(
5031 err: &mut DiagnosticBuilder<'tcx>,
5032 expression: &'gcx hir::Expr,
5038 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5039 let mut pointing_at_return_type = false;
5040 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5041 pointing_at_return_type = self.suggest_missing_return_type(
5042 err, &fn_decl, expected, found, can_suggest);
5044 self.suggest_ref_or_into(err, expression, expected, found);
5045 pointing_at_return_type
5048 pub fn suggest_ref_or_into(
5050 err: &mut DiagnosticBuilder<'tcx>,
5055 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5056 err.span_suggestion(
5060 Applicability::MachineApplicable,
5062 } else if !self.check_for_cast(err, expr, found, expected) {
5063 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5067 let methods = self.get_conversion_methods(expr.span, expected, found);
5068 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5069 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5070 .filter_map(|(receiver, method)| {
5071 let method_call = format!(".{}()", method.ident);
5072 if receiver.ends_with(&method_call) {
5073 None // do not suggest code that is already there (#53348)
5075 let method_call_list = [".to_vec()", ".to_string()"];
5076 let sugg = if receiver.ends_with(".clone()")
5077 && method_call_list.contains(&method_call.as_str()) {
5078 let max_len = receiver.rfind(".").unwrap();
5079 format!("{}{}", &receiver[..max_len], method_call)
5081 format!("{}{}", receiver, method_call)
5083 Some(if is_struct_pat_shorthand_field {
5084 format!("{}: {}", receiver, sugg)
5090 if suggestions.peek().is_some() {
5091 err.span_suggestions(
5093 "try using a conversion method",
5095 Applicability::MaybeIncorrect,
5102 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5106 /// bar_that_returns_u32()
5110 /// This routine checks if the return expression in a block would make sense on its own as a
5111 /// statement and the return type has been left as default or has been specified as `()`. If so,
5112 /// it suggests adding a semicolon.
5113 fn suggest_missing_semicolon(&self,
5114 err: &mut DiagnosticBuilder<'tcx>,
5115 expression: &'gcx hir::Expr,
5118 if expected.is_unit() {
5119 // `BlockTailExpression` only relevant if the tail expr would be
5120 // useful on its own.
5121 match expression.node {
5122 ExprKind::Call(..) |
5123 ExprKind::MethodCall(..) |
5124 ExprKind::While(..) |
5125 ExprKind::Loop(..) |
5126 ExprKind::Match(..) |
5127 ExprKind::Block(..) => {
5128 let sp = self.tcx.sess.source_map().next_point(cause_span);
5129 err.span_suggestion(
5131 "try adding a semicolon",
5133 Applicability::MachineApplicable);
5140 /// A possible error is to forget to add a return type that is needed:
5144 /// bar_that_returns_u32()
5148 /// This routine checks if the return type is left as default, the method is not part of an
5149 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5151 fn suggest_missing_return_type(
5153 err: &mut DiagnosticBuilder<'tcx>,
5154 fn_decl: &hir::FnDecl,
5159 // Only suggest changing the return type for methods that
5160 // haven't set a return type at all (and aren't `fn main()` or an impl).
5161 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5162 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5163 err.span_suggestion(
5165 "try adding a return type",
5166 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5167 Applicability::MachineApplicable);
5170 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5171 err.span_label(span, "possibly return type missing here?");
5174 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5175 // `fn main()` must return `()`, do not suggest changing return type
5176 err.span_label(span, "expected `()` because of default return type");
5179 // expectation was caused by something else, not the default return
5180 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5181 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5182 // Only point to return type if the expected type is the return type, as if they
5183 // are not, the expectation must have been caused by something else.
5184 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5186 let ty = AstConv::ast_ty_to_ty(self, ty);
5187 debug!("suggest_missing_return_type: return type {:?}", ty);
5188 debug!("suggest_missing_return_type: expected type {:?}", ty);
5189 if ty.sty == expected.sty {
5190 err.span_label(sp, format!("expected `{}` because of return type",
5199 /// A common error is to add an extra semicolon:
5202 /// fn foo() -> usize {
5207 /// This routine checks if the final statement in a block is an
5208 /// expression with an explicit semicolon whose type is compatible
5209 /// with `expected_ty`. If so, it suggests removing the semicolon.
5210 fn consider_hint_about_removing_semicolon(
5212 blk: &'gcx hir::Block,
5213 expected_ty: Ty<'tcx>,
5214 err: &mut DiagnosticBuilder<'_>,
5216 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5217 err.span_suggestion(
5219 "consider removing this semicolon",
5221 Applicability::MachineApplicable,
5226 fn could_remove_semicolon(
5228 blk: &'gcx hir::Block,
5229 expected_ty: Ty<'tcx>,
5231 // Be helpful when the user wrote `{... expr;}` and
5232 // taking the `;` off is enough to fix the error.
5233 let last_stmt = blk.stmts.last()?;
5234 let last_expr = match last_stmt.node {
5235 hir::StmtKind::Semi(ref e) => e,
5238 let last_expr_ty = self.node_ty(last_expr.hir_id);
5239 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5242 let original_span = original_sp(last_stmt.span, blk.span);
5243 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5246 // Rewrite `SelfCtor` to `Ctor`
5247 pub fn rewrite_self_ctor(
5251 ) -> Result<Res, ErrorReported> {
5253 if let Res::SelfCtor(impl_def_id) = res {
5254 let ty = self.impl_self_ty(span, impl_def_id).ty;
5255 let adt_def = ty.ty_adt_def();
5258 Some(adt_def) if adt_def.has_ctor() => {
5259 let variant = adt_def.non_enum_variant();
5260 let ctor_def_id = variant.ctor_def_id.unwrap();
5261 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5264 let mut err = tcx.sess.struct_span_err(span,
5265 "the `Self` constructor can only be used with tuple or unit structs");
5266 if let Some(adt_def) = adt_def {
5267 match adt_def.adt_kind() {
5269 err.help("did you mean to use one of the enum's variants?");
5273 err.span_suggestion(
5275 "use curly brackets",
5276 String::from("Self { /* fields */ }"),
5277 Applicability::HasPlaceholders,
5292 // Instantiates the given path, which must refer to an item with the given
5293 // number of type parameters and type.
5294 pub fn instantiate_value_path(&self,
5295 segments: &[hir::PathSegment],
5296 self_ty: Option<Ty<'tcx>>,
5300 -> (Ty<'tcx>, Res) {
5302 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5311 let res = match self.rewrite_self_ctor(res, span) {
5313 Err(ErrorReported) => return (tcx.types.err, res),
5315 let path_segs = match res {
5316 Res::Local(_) => vec![],
5317 Res::Def(kind, def_id) =>
5318 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5319 _ => bug!("instantiate_value_path on {:?}", res),
5322 let mut user_self_ty = None;
5323 let mut is_alias_variant_ctor = false;
5325 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5326 if let Some(self_ty) = self_ty {
5327 let adt_def = self_ty.ty_adt_def().unwrap();
5328 user_self_ty = Some(UserSelfTy {
5329 impl_def_id: adt_def.did,
5332 is_alias_variant_ctor = true;
5335 Res::Def(DefKind::Method, def_id)
5336 | Res::Def(DefKind::AssocConst, def_id) => {
5337 let container = tcx.associated_item(def_id).container;
5338 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5340 ty::TraitContainer(trait_did) => {
5341 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5343 ty::ImplContainer(impl_def_id) => {
5344 if segments.len() == 1 {
5345 // `<T>::assoc` will end up here, and so
5346 // can `T::assoc`. It this came from an
5347 // inherent impl, we need to record the
5348 // `T` for posterity (see `UserSelfTy` for
5350 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5351 user_self_ty = Some(UserSelfTy {
5362 // Now that we have categorized what space the parameters for each
5363 // segment belong to, let's sort out the parameters that the user
5364 // provided (if any) into their appropriate spaces. We'll also report
5365 // errors if type parameters are provided in an inappropriate place.
5367 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5368 let generics_has_err = AstConv::prohibit_generics(
5369 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5370 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5377 if let Res::Local(hid) = res {
5378 let ty = self.local_ty(span, hid).decl_ty;
5379 let ty = self.normalize_associated_types_in(span, &ty);
5380 self.write_ty(hir_id, ty);
5384 if generics_has_err {
5385 // Don't try to infer type parameters when prohibited generic arguments were given.
5386 user_self_ty = None;
5389 // Now we have to compare the types that the user *actually*
5390 // provided against the types that were *expected*. If the user
5391 // did not provide any types, then we want to substitute inference
5392 // variables. If the user provided some types, we may still need
5393 // to add defaults. If the user provided *too many* types, that's
5396 let mut infer_args_for_err = FxHashSet::default();
5397 for &PathSeg(def_id, index) in &path_segs {
5398 let seg = &segments[index];
5399 let generics = tcx.generics_of(def_id);
5400 // Argument-position `impl Trait` is treated as a normal generic
5401 // parameter internally, but we don't allow users to specify the
5402 // parameter's value explicitly, so we have to do some error-
5404 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5409 false, // `is_method_call`
5411 if suppress_errors {
5412 infer_args_for_err.insert(index);
5413 self.set_tainted_by_errors(); // See issue #53251.
5417 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5418 tcx.generics_of(*def_id).has_self
5419 }).unwrap_or(false);
5421 let def_id = res.def_id();
5423 // The things we are substituting into the type should not contain
5424 // escaping late-bound regions, and nor should the base type scheme.
5425 let ty = tcx.type_of(def_id);
5427 let substs = AstConv::create_substs_for_generic_args(
5433 // Provide the generic args, and whether types should be inferred.
5435 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5438 // If we've encountered an `impl Trait`-related error, we're just
5439 // going to infer the arguments for better error messages.
5440 if !infer_args_for_err.contains(&index) {
5441 // Check whether the user has provided generic arguments.
5442 if let Some(ref data) = segments[index].args {
5443 return (Some(data), segments[index].infer_args);
5446 return (None, segments[index].infer_args);
5451 // Provide substitutions for parameters for which (valid) arguments have been provided.
5453 match (¶m.kind, arg) {
5454 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5455 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5457 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5458 self.to_ty(ty).into()
5460 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5461 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5463 _ => unreachable!(),
5466 // Provide substitutions for parameters for which arguments are inferred.
5467 |substs, param, infer_args| {
5469 GenericParamDefKind::Lifetime => {
5470 self.re_infer(Some(param), span).unwrap().into()
5472 GenericParamDefKind::Type { has_default, .. } => {
5473 if !infer_args && has_default {
5474 // If we have a default, then we it doesn't matter that we're not
5475 // inferring the type arguments: we provide the default where any
5477 let default = tcx.type_of(param.def_id);
5480 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5483 // If no type arguments were provided, we have to infer them.
5484 // This case also occurs as a result of some malformed input, e.g.
5485 // a lifetime argument being given instead of a type parameter.
5486 // Using inference instead of `Error` gives better error messages.
5487 self.var_for_def(span, param)
5490 GenericParamDefKind::Const => {
5491 // FIXME(const_generics:defaults)
5492 // No const parameters were provided, we have to infer them.
5493 self.var_for_def(span, param)
5498 assert!(!substs.has_escaping_bound_vars());
5499 assert!(!ty.has_escaping_bound_vars());
5501 // First, store the "user substs" for later.
5502 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5504 // Add all the obligations that are required, substituting and
5505 // normalized appropriately.
5506 let bounds = self.instantiate_bounds(span, def_id, &substs);
5507 self.add_obligations_for_parameters(
5508 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5511 // Substitute the values for the type parameters into the type of
5512 // the referenced item.
5513 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5515 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5516 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5517 // is inherent, there is no `Self` parameter; instead, the impl needs
5518 // type parameters, which we can infer by unifying the provided `Self`
5519 // with the substituted impl type.
5520 // This also occurs for an enum variant on a type alias.
5521 let ty = tcx.type_of(impl_def_id);
5523 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5524 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5525 Ok(ok) => self.register_infer_ok_obligations(ok),
5527 self.tcx.sess.delay_span_bug(span, &format!(
5528 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5536 self.check_rustc_args_require_const(def_id, hir_id, span);
5538 debug!("instantiate_value_path: type of {:?} is {:?}",
5541 self.write_substs(hir_id, substs);
5543 (ty_substituted, res)
5546 fn check_rustc_args_require_const(&self,
5550 // We're only interested in functions tagged with
5551 // #[rustc_args_required_const], so ignore anything that's not.
5552 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5556 // If our calling expression is indeed the function itself, we're good!
5557 // If not, generate an error that this can only be called directly.
5558 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5559 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5561 if let ExprKind::Call(ref callee, ..) = expr.node {
5562 if callee.hir_id == hir_id {
5568 self.tcx.sess.span_err(span, "this function can only be invoked \
5569 directly, not through a function pointer");
5572 // Resolves `typ` by a single level if `typ` is a type variable.
5573 // If no resolution is possible, then an error is reported.
5574 // Numeric inference variables may be left unresolved.
5575 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5576 let ty = self.resolve_type_vars_with_obligations(ty);
5577 if !ty.is_ty_var() {
5580 if !self.is_tainted_by_errors() {
5581 self.need_type_info_err((**self).body_id, sp, ty)
5582 .note("type must be known at this point")
5585 self.demand_suptype(sp, self.tcx.types.err, ty);
5590 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5591 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5592 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5595 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5596 index = enclosing_breakables.stack.len();
5597 enclosing_breakables.by_id.insert(id, index);
5598 enclosing_breakables.stack.push(ctxt);
5602 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5603 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5604 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5605 enclosing_breakables.stack.pop().expect("missing breakable context")
5610 /// Instantiate a QueryResponse in a probe context, without a
5611 /// good ObligationCause.
5612 fn probe_instantiate_query_response(
5615 original_values: &OriginalQueryValues<'tcx>,
5616 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5617 ) -> InferResult<'tcx, Ty<'tcx>>
5619 self.instantiate_query_response_and_region_obligations(
5620 &traits::ObligationCause::misc(span, self.body_id),
5626 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5627 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5628 let mut contained_in_place = false;
5630 while let hir::Node::Expr(parent_expr) =
5631 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5633 match &parent_expr.node {
5634 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5635 if lhs.hir_id == expr_id {
5636 contained_in_place = true;
5642 expr_id = parent_expr.hir_id;
5649 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
5650 generics: &ty::Generics,
5652 let own_counts = generics.own_counts();
5654 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5660 if own_counts.types == 0 {
5664 // Make a vector of booleans initially false, set to true when used.
5665 let mut types_used = vec![false; own_counts.types];
5667 for leaf_ty in ty.walk() {
5668 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5669 debug!("Found use of ty param num {}", index);
5670 types_used[index as usize - own_counts.lifetimes] = true;
5671 } else if let ty::Error = leaf_ty.sty {
5672 // If there is already another error, do not emit
5673 // an error for not using a type Parameter.
5674 assert!(tcx.sess.err_count() > 0);
5679 let types = generics.params.iter().filter(|param| match param.kind {
5680 ty::GenericParamDefKind::Type { .. } => true,
5683 for (&used, param) in types_used.iter().zip(types) {
5685 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5686 let span = tcx.hir().span_by_hir_id(id);
5687 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5688 .span_label(span, "unused type parameter")
5694 fn fatally_break_rust(sess: &Session) {
5695 let handler = sess.diagnostic();
5696 handler.span_bug_no_panic(
5698 "It looks like you're trying to break rust; would you like some ICE?",
5700 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5701 handler.note_without_error(
5702 "we would appreciate a joke overview: \
5703 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5705 handler.note_without_error(&format!("rustc {} running on {}",
5706 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5707 crate::session::config::host_triple(),
5711 fn potentially_plural_count(count: usize, word: &str) -> String {
5712 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })