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<'gcx, 'tcx> {
592 infcx: infer::InferCtxtBuilder<'gcx, 'tcx>,
596 impl Inherited<'_, 'gcx, 'tcx> {
597 pub fn build(tcx: TyCtxt<'gcx, 'gcx>, def_id: DefId) -> InheritedBuilder<'gcx, 'tcx> {
598 let hir_id_root = if def_id.is_local() {
599 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
600 DefId::local(hir_id.owner)
606 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
612 impl<'gcx, 'tcx> InheritedBuilder<'gcx, 'tcx> {
613 fn enter<F, R>(&'tcx mut self, f: F) -> R
615 F: for<'a> FnOnce(Inherited<'a, 'gcx, 'tcx>) -> R,
617 let def_id = self.def_id;
618 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
622 impl 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<'tcx> {
689 tcx: TyCtxt<'tcx, 'tcx>,
692 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
693 fn visit_item(&mut self, i: &'tcx hir::Item) {
694 check_item_type(self.tcx, i);
696 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
697 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
700 pub fn check_wf_new<'tcx>(tcx: TyCtxt<'tcx, 'tcx>) -> Result<(), ErrorReported> {
701 tcx.sess.track_errors(|| {
702 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
703 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
707 fn check_mod_item_types<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, module_def_id: DefId) {
708 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
711 fn typeck_item_bodies<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, crate_num: CrateNum) {
712 debug_assert!(crate_num == LOCAL_CRATE);
713 tcx.par_body_owners(|body_owner_def_id| {
714 tcx.ensure().typeck_tables_of(body_owner_def_id);
718 fn check_item_well_formed<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) {
719 wfcheck::check_item_well_formed(tcx, def_id);
722 fn check_trait_item_well_formed<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) {
723 wfcheck::check_trait_item(tcx, def_id);
726 fn check_impl_item_well_formed<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) {
727 wfcheck::check_impl_item(tcx, def_id);
730 pub fn provide(providers: &mut Providers<'_>) {
731 method::provide(providers);
732 *providers = Providers {
738 check_item_well_formed,
739 check_trait_item_well_formed,
740 check_impl_item_well_formed,
741 check_mod_item_types,
746 fn adt_destructor<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> 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<'tcx>(
760 tcx: TyCtxt<'tcx, 'tcx>,
762 ) -> 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<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> bool {
801 // Closures' tables come from their outermost function,
802 // as they are part of the same "inference environment".
803 let outer_def_id = tcx.closure_base_def_id(def_id);
804 if outer_def_id != def_id {
805 return tcx.has_typeck_tables(outer_def_id);
808 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
809 primary_body_of(tcx, id).is_some()
812 fn used_trait_imports<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> &'tcx DefIdSet {
813 &*tcx.typeck_tables_of(def_id).used_trait_imports
816 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::TypeckTables<'tcx> {
817 // Closures' tables come from their outermost function,
818 // as they are part of the same "inference environment".
819 let outer_def_id = tcx.closure_base_def_id(def_id);
820 if outer_def_id != def_id {
821 return tcx.typeck_tables_of(outer_def_id);
824 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
825 let span = tcx.hir().span_by_hir_id(id);
827 // Figure out what primary body this item has.
828 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
829 span_bug!(span, "can't type-check body of {:?}", def_id);
831 let body = tcx.hir().body(body_id);
833 let tables = Inherited::build(tcx, def_id).enter(|inh| {
834 let param_env = tcx.param_env(def_id);
835 let fcx = if let Some(decl) = fn_decl {
836 let fn_sig = tcx.fn_sig(def_id);
838 check_abi(tcx, span, fn_sig.abi());
840 // Compute the fty from point of view of inside the fn.
842 tcx.liberate_late_bound_regions(def_id, &fn_sig);
844 inh.normalize_associated_types_in(body.value.span,
849 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
852 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
853 let expected_type = tcx.type_of(def_id);
854 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
855 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
857 let revealed_ty = if tcx.features().impl_trait_in_bindings {
858 fcx.instantiate_opaque_types_from_value(
866 // Gather locals in statics (because of block expressions).
867 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
871 fcx.write_ty(id, revealed_ty);
876 // All type checking constraints were added, try to fallback unsolved variables.
877 fcx.select_obligations_where_possible(false);
878 let mut fallback_has_occurred = false;
879 for ty in &fcx.unsolved_variables() {
880 fallback_has_occurred |= fcx.fallback_if_possible(ty);
882 fcx.select_obligations_where_possible(fallback_has_occurred);
884 // Even though coercion casts provide type hints, we check casts after fallback for
885 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
888 // Closure and generator analysis may run after fallback
889 // because they don't constrain other type variables.
890 fcx.closure_analyze(body);
891 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
892 fcx.resolve_generator_interiors(def_id);
894 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
895 let ty = fcx.normalize_ty(span, ty);
896 fcx.require_type_is_sized(ty, span, code);
898 fcx.select_all_obligations_or_error();
900 if fn_decl.is_some() {
901 fcx.regionck_fn(id, body);
903 fcx.regionck_expr(body);
906 fcx.resolve_type_vars_in_body(body)
909 // Consistency check our TypeckTables instance can hold all ItemLocalIds
910 // it will need to hold.
911 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
916 fn check_abi<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, span: Span, abi: Abi) {
917 if !tcx.sess.target.target.is_abi_supported(abi) {
918 struct_span_err!(tcx.sess, span, E0570,
919 "The ABI `{}` is not supported for the current target", abi).emit()
923 struct GatherLocalsVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
924 fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'gcx, 'tcx> GatherLocalsVisitor<'a, 'gcx, 'tcx> {
929 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
934 kind: TypeVariableOriginKind::TypeInference,
937 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
944 // take type that the user specified
945 self.fcx.locals.borrow_mut().insert(nid, typ);
952 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
953 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
954 NestedVisitorMap::None
957 // Add explicitly-declared locals.
958 fn visit_local(&mut self, local: &'gcx hir::Local) {
959 let local_ty = match local.ty {
961 let o_ty = self.fcx.to_ty(&ty);
963 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
964 self.fcx.instantiate_opaque_types_from_value(
972 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
973 &UserType::Ty(revealed_ty)
975 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
976 ty.hir_id, o_ty, revealed_ty, c_ty);
977 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
979 Some(LocalTy { decl_ty: o_ty, revealed_ty })
983 self.assign(local.span, local.hir_id, local_ty);
985 debug!("Local variable {:?} is assigned type {}",
987 self.fcx.ty_to_string(
988 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
989 intravisit::walk_local(self, local);
992 // Add pattern bindings.
993 fn visit_pat(&mut self, p: &'gcx hir::Pat) {
994 if let PatKind::Binding(_, _, ident, _) = p.node {
995 let var_ty = self.assign(p.span, p.hir_id, None);
997 let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
998 if !self.fcx.tcx.features().unsized_locals {
999 self.fcx.require_type_is_sized(var_ty, p.span,
1000 traits::VariableType(node_id));
1003 debug!("Pattern binding {} is assigned to {} with type {:?}",
1005 self.fcx.ty_to_string(
1006 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1009 intravisit::walk_pat(self, p);
1012 // Don't descend into the bodies of nested closures
1013 fn visit_fn(&mut self, _: intravisit::FnKind<'gcx>, _: &'gcx hir::FnDecl,
1014 _: hir::BodyId, _: Span, _: hir::HirId) { }
1017 /// When `check_fn` is invoked on a generator (i.e., a body that
1018 /// includes yield), it returns back some information about the yield
1020 struct GeneratorTypes<'tcx> {
1021 /// Type of value that is yielded.
1024 /// Types that are captured (see `GeneratorInterior` for more).
1027 /// Indicates if the generator is movable or static (immovable).
1028 movability: hir::GeneratorMovability,
1031 /// Helper used for fns and closures. Does the grungy work of checking a function
1032 /// body and returns the function context used for that purpose, since in the case of a fn item
1033 /// there is still a bit more to do.
1036 /// * inherited: other fields inherited from the enclosing fn (if any)
1037 fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
1038 param_env: ty::ParamEnv<'tcx>,
1039 fn_sig: ty::FnSig<'tcx>,
1040 decl: &'gcx hir::FnDecl,
1042 body: &'gcx hir::Body,
1043 can_be_generator: Option<hir::GeneratorMovability>)
1044 -> (FnCtxt<'a, 'gcx, 'tcx>, Option<GeneratorTypes<'tcx>>)
1046 let mut fn_sig = fn_sig.clone();
1048 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1050 // Create the function context. This is either derived from scratch or,
1051 // in the case of closures, based on the outer context.
1052 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1053 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1055 let declared_ret_ty = fn_sig.output();
1056 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1057 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty);
1058 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1059 fn_sig = fcx.tcx.mk_fn_sig(
1060 fn_sig.inputs().iter().cloned(),
1067 let span = body.value.span;
1069 if body.is_generator && can_be_generator.is_some() {
1070 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1071 kind: TypeVariableOriginKind::TypeInference,
1074 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1075 fcx.yield_ty = Some(yield_ty);
1078 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id_from_hir_id(fn_id));
1079 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1080 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1082 // Add formal parameters.
1083 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1084 // Check the pattern.
1085 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1086 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1088 // Check that argument is Sized.
1089 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1090 // for simple cases like `fn foo(x: Trait)`,
1091 // where we would error once on the parameter as a whole, and once on the binding `x`.
1092 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1093 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1096 fcx.write_ty(arg.hir_id, arg_ty);
1099 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1101 fcx.check_return_expr(&body.value);
1103 // We insert the deferred_generator_interiors entry after visiting the body.
1104 // This ensures that all nested generators appear before the entry of this generator.
1105 // resolve_generator_interiors relies on this property.
1106 let gen_ty = if can_be_generator.is_some() && body.is_generator {
1107 let interior = fcx.next_ty_var(TypeVariableOrigin {
1108 kind: TypeVariableOriginKind::MiscVariable,
1111 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior));
1112 Some(GeneratorTypes {
1113 yield_ty: fcx.yield_ty.unwrap(),
1115 movability: can_be_generator.unwrap(),
1121 // Finalize the return check by taking the LUB of the return types
1122 // we saw and assigning it to the expected return type. This isn't
1123 // really expected to fail, since the coercions would have failed
1124 // earlier when trying to find a LUB.
1126 // However, the behavior around `!` is sort of complex. In the
1127 // event that the `actual_return_ty` comes back as `!`, that
1128 // indicates that the fn either does not return or "returns" only
1129 // values of type `!`. In this case, if there is an expected
1130 // return type that is *not* `!`, that should be ok. But if the
1131 // return type is being inferred, we want to "fallback" to `!`:
1133 // let x = move || panic!();
1135 // To allow for that, I am creating a type variable with diverging
1136 // fallback. This was deemed ever so slightly better than unifying
1137 // the return value with `!` because it allows for the caller to
1138 // make more assumptions about the return type (e.g., they could do
1140 // let y: Option<u32> = Some(x());
1142 // which would then cause this return type to become `u32`, not
1144 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1145 let mut actual_return_ty = coercion.complete(&fcx);
1146 if actual_return_ty.is_never() {
1147 actual_return_ty = fcx.next_diverging_ty_var(
1148 TypeVariableOrigin {
1149 kind: TypeVariableOriginKind::DivergingFn,
1154 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1156 // Check that the main return type implements the termination trait.
1157 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1158 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1159 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1160 if main_id == fn_id {
1161 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1162 let trait_ref = ty::TraitRef::new(term_id, substs);
1163 let return_ty_span = decl.output.span();
1164 let cause = traits::ObligationCause::new(
1165 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1167 inherited.register_predicate(
1168 traits::Obligation::new(
1169 cause, param_env, trait_ref.to_predicate()));
1174 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1175 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1176 if panic_impl_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1177 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1178 // at this point we don't care if there are duplicate handlers or if the handler has
1179 // the wrong signature as this value we'll be used when writing metadata and that
1180 // only happens if compilation succeeded
1181 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1183 if declared_ret_ty.sty != ty::Never {
1184 fcx.tcx.sess.span_err(
1186 "return type should be `!`",
1190 let inputs = fn_sig.inputs();
1191 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1192 if inputs.len() == 1 {
1193 let arg_is_panic_info = match inputs[0].sty {
1194 ty::Ref(region, ty, mutbl) => match ty.sty {
1195 ty::Adt(ref adt, _) => {
1196 adt.did == panic_info_did &&
1197 mutbl == hir::Mutability::MutImmutable &&
1198 *region != RegionKind::ReStatic
1205 if !arg_is_panic_info {
1206 fcx.tcx.sess.span_err(
1207 decl.inputs[0].span,
1208 "argument should be `&PanicInfo`",
1212 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1213 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1214 if !generics.params.is_empty() {
1215 fcx.tcx.sess.span_err(
1217 "should have no type parameters",
1223 let span = fcx.tcx.sess.source_map().def_span(span);
1224 fcx.tcx.sess.span_err(span, "function should have one argument");
1227 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1232 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1233 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1234 if alloc_error_handler_did == fcx.tcx.hir().local_def_id_from_hir_id(fn_id) {
1235 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1236 if declared_ret_ty.sty != ty::Never {
1237 fcx.tcx.sess.span_err(
1239 "return type should be `!`",
1243 let inputs = fn_sig.inputs();
1244 let span = fcx.tcx.hir().span_by_hir_id(fn_id);
1245 if inputs.len() == 1 {
1246 let arg_is_alloc_layout = match inputs[0].sty {
1247 ty::Adt(ref adt, _) => {
1248 adt.did == alloc_layout_did
1253 if !arg_is_alloc_layout {
1254 fcx.tcx.sess.span_err(
1255 decl.inputs[0].span,
1256 "argument should be `Layout`",
1260 if let Node::Item(item) = fcx.tcx.hir().get_by_hir_id(fn_id) {
1261 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1262 if !generics.params.is_empty() {
1263 fcx.tcx.sess.span_err(
1265 "`#[alloc_error_handler]` function should have no type \
1272 let span = fcx.tcx.sess.source_map().def_span(span);
1273 fcx.tcx.sess.span_err(span, "function should have one argument");
1276 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1284 fn check_struct<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, id: hir::HirId, span: Span) {
1285 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1286 let def = tcx.adt_def(def_id);
1287 def.destructor(tcx); // force the destructor to be evaluated
1288 check_representable(tcx, span, def_id);
1290 if def.repr.simd() {
1291 check_simd(tcx, span, def_id);
1294 check_transparent(tcx, span, def_id);
1295 check_packed(tcx, span, def_id);
1298 fn check_union<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, id: hir::HirId, span: Span) {
1299 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1300 let def = tcx.adt_def(def_id);
1301 def.destructor(tcx); // force the destructor to be evaluated
1302 check_representable(tcx, span, def_id);
1303 check_transparent(tcx, span, def_id);
1304 check_packed(tcx, span, def_id);
1307 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1308 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1309 let mut err = struct_span_err!(
1310 tcx.sess, span, E0720,
1311 "opaque type expands to a recursive type",
1313 err.span_label(span, "expands to self-referential type");
1314 if let ty::Opaque(..) = partially_expanded_type.sty {
1315 err.note("type resolves to itself");
1317 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1323 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, it: &'tcx hir::Item) {
1325 "check_item_type(it.hir_id={}, it.name={})",
1327 tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
1329 let _indenter = indenter();
1331 // Consts can play a role in type-checking, so they are included here.
1332 hir::ItemKind::Static(..) => {
1333 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1334 tcx.typeck_tables_of(def_id);
1335 maybe_check_static_with_link_section(tcx, def_id, it.span);
1337 hir::ItemKind::Const(..) => {
1338 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(it.hir_id));
1340 hir::ItemKind::Enum(ref enum_definition, _) => {
1341 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1343 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1344 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1345 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1346 let impl_def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1347 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1348 check_impl_items_against_trait(
1355 let trait_def_id = impl_trait_ref.def_id;
1356 check_on_unimplemented(tcx, trait_def_id, it);
1359 hir::ItemKind::Trait(..) => {
1360 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1361 check_on_unimplemented(tcx, def_id, it);
1363 hir::ItemKind::Struct(..) => {
1364 check_struct(tcx, it.hir_id, it.span);
1366 hir::ItemKind::Union(..) => {
1367 check_union(tcx, it.hir_id, it.span);
1369 hir::ItemKind::Existential(..) => {
1370 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1372 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1373 check_opaque(tcx, def_id, substs, it.span);
1375 hir::ItemKind::Ty(..) => {
1376 let def_id = tcx.hir().local_def_id_from_hir_id(it.hir_id);
1377 let pty_ty = tcx.type_of(def_id);
1378 let generics = tcx.generics_of(def_id);
1379 check_bounds_are_used(tcx, &generics, pty_ty);
1381 hir::ItemKind::ForeignMod(ref m) => {
1382 check_abi(tcx, it.span, m.abi);
1384 if m.abi == Abi::RustIntrinsic {
1385 for item in &m.items {
1386 intrinsic::check_intrinsic_type(tcx, item);
1388 } else if m.abi == Abi::PlatformIntrinsic {
1389 for item in &m.items {
1390 intrinsic::check_platform_intrinsic_type(tcx, item);
1393 for item in &m.items {
1394 let generics = tcx.generics_of(tcx.hir().local_def_id_from_hir_id(item.hir_id));
1395 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1396 let mut err = struct_span_err!(
1400 "foreign items may not have type parameters"
1402 err.span_label(item.span, "can't have type parameters");
1403 // FIXME: once we start storing spans for type arguments, turn this into a
1406 "use specialization instead of type parameters by replacing them \
1407 with concrete types like `u32`",
1412 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1413 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1418 _ => { /* nothing to do */ }
1422 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_, '_>, id: DefId, span: Span) {
1423 // Only restricted on wasm32 target for now
1424 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1428 // If `#[link_section]` is missing, then nothing to verify
1429 let attrs = tcx.codegen_fn_attrs(id);
1430 if attrs.link_section.is_none() {
1434 // For the wasm32 target statics with #[link_section] are placed into custom
1435 // sections of the final output file, but this isn't link custom sections of
1436 // other executable formats. Namely we can only embed a list of bytes,
1437 // nothing with pointers to anything else or relocations. If any relocation
1438 // show up, reject them here.
1439 let instance = ty::Instance::mono(tcx, id);
1440 let cid = GlobalId {
1444 let param_env = ty::ParamEnv::reveal_all();
1445 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1446 let alloc = if let ConstValue::ByRef(_, allocation) = static_.val {
1449 bug!("Matching on non-ByRef static")
1451 if alloc.relocations.len() != 0 {
1452 let msg = "statics with a custom `#[link_section]` must be a \
1453 simple list of bytes on the wasm target with no \
1454 extra levels of indirection such as references";
1455 tcx.sess.span_err(span, msg);
1460 fn check_on_unimplemented<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, trait_def_id: DefId, item: &hir::Item) {
1461 let item_def_id = tcx.hir().local_def_id_from_hir_id(item.hir_id);
1462 // an error would be reported if this fails.
1463 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1466 fn report_forbidden_specialization<'tcx>(
1467 tcx: TyCtxt<'tcx, 'tcx>,
1468 impl_item: &hir::ImplItem,
1471 let mut err = struct_span_err!(
1472 tcx.sess, impl_item.span, E0520,
1473 "`{}` specializes an item from a parent `impl`, but \
1474 that item is not marked `default`",
1476 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1479 match tcx.span_of_impl(parent_impl) {
1481 err.span_label(span, "parent `impl` is here");
1482 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1486 err.note(&format!("parent implementation is in crate `{}`", cname));
1493 fn check_specialization_validity<'tcx>(
1494 tcx: TyCtxt<'tcx, 'tcx>,
1495 trait_def: &ty::TraitDef,
1496 trait_item: &ty::AssocItem,
1498 impl_item: &hir::ImplItem,
1500 let ancestors = trait_def.ancestors(tcx, impl_id);
1502 let kind = match impl_item.node {
1503 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1504 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1505 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1506 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1509 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1510 .map(|node_item| node_item.map(|parent| parent.defaultness));
1512 if let Some(parent) = parent {
1513 if tcx.impl_item_is_final(&parent) {
1514 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1520 fn check_impl_items_against_trait<'tcx>(
1521 tcx: TyCtxt<'tcx, 'tcx>,
1524 impl_trait_ref: ty::TraitRef<'tcx>,
1525 impl_item_refs: &[hir::ImplItemRef],
1527 let impl_span = tcx.sess.source_map().def_span(impl_span);
1529 // If the trait reference itself is erroneous (so the compilation is going
1530 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1531 // isn't populated for such impls.
1532 if impl_trait_ref.references_error() { return; }
1534 // Locate trait definition and items
1535 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1536 let mut overridden_associated_type = None;
1538 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1540 // Check existing impl methods to see if they are both present in trait
1541 // and compatible with trait signature
1542 for impl_item in impl_items() {
1543 let ty_impl_item = tcx.associated_item(
1544 tcx.hir().local_def_id_from_hir_id(impl_item.hir_id));
1545 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1546 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1547 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1549 // Not compatible, but needed for the error message
1550 tcx.associated_items(impl_trait_ref.def_id)
1551 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1554 // Check that impl definition matches trait definition
1555 if let Some(ty_trait_item) = ty_trait_item {
1556 match impl_item.node {
1557 hir::ImplItemKind::Const(..) => {
1558 // Find associated const definition.
1559 if ty_trait_item.kind == ty::AssocKind::Const {
1560 compare_const_impl(tcx,
1566 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1567 "item `{}` is an associated const, \
1568 which doesn't match its trait `{}`",
1571 err.span_label(impl_item.span, "does not match trait");
1572 // We can only get the spans from local trait definition
1573 // Same for E0324 and E0325
1574 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1575 err.span_label(trait_span, "item in trait");
1580 hir::ImplItemKind::Method(..) => {
1581 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1582 if ty_trait_item.kind == ty::AssocKind::Method {
1583 compare_impl_method(tcx,
1590 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1591 "item `{}` is an associated method, \
1592 which doesn't match its trait `{}`",
1595 err.span_label(impl_item.span, "does not match trait");
1596 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1597 err.span_label(trait_span, "item in trait");
1602 hir::ImplItemKind::Existential(..) |
1603 hir::ImplItemKind::Type(_) => {
1604 if ty_trait_item.kind == ty::AssocKind::Type {
1605 if ty_trait_item.defaultness.has_value() {
1606 overridden_associated_type = Some(impl_item);
1609 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1610 "item `{}` is an associated type, \
1611 which doesn't match its trait `{}`",
1614 err.span_label(impl_item.span, "does not match trait");
1615 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1616 err.span_label(trait_span, "item in trait");
1623 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1627 // Check for missing items from trait
1628 let mut missing_items = Vec::new();
1629 let mut invalidated_items = Vec::new();
1630 let associated_type_overridden = overridden_associated_type.is_some();
1631 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1632 let is_implemented = trait_def.ancestors(tcx, impl_id)
1633 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1635 .map(|node_item| !node_item.node.is_from_trait())
1638 if !is_implemented && !tcx.impl_is_default(impl_id) {
1639 if !trait_item.defaultness.has_value() {
1640 missing_items.push(trait_item);
1641 } else if associated_type_overridden {
1642 invalidated_items.push(trait_item.ident);
1647 if !missing_items.is_empty() {
1648 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1649 "not all trait items implemented, missing: `{}`",
1650 missing_items.iter()
1651 .map(|trait_item| trait_item.ident.to_string())
1652 .collect::<Vec<_>>().join("`, `"));
1653 err.span_label(impl_span, format!("missing `{}` in implementation",
1654 missing_items.iter()
1655 .map(|trait_item| trait_item.ident.to_string())
1656 .collect::<Vec<_>>().join("`, `")));
1657 for trait_item in missing_items {
1658 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1659 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1661 err.note_trait_signature(trait_item.ident.to_string(),
1662 trait_item.signature(tcx));
1668 if !invalidated_items.is_empty() {
1669 let invalidator = overridden_associated_type.unwrap();
1670 span_err!(tcx.sess, invalidator.span, E0399,
1671 "the following trait items need to be reimplemented \
1672 as `{}` was overridden: `{}`",
1674 invalidated_items.iter()
1675 .map(|name| name.to_string())
1676 .collect::<Vec<_>>().join("`, `"))
1680 /// Checks whether a type can be represented in memory. In particular, it
1681 /// identifies types that contain themselves without indirection through a
1682 /// pointer, which would mean their size is unbounded.
1683 fn check_representable<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, sp: Span, item_def_id: DefId) -> bool {
1684 let rty = tcx.type_of(item_def_id);
1686 // Check that it is possible to represent this type. This call identifies
1687 // (1) types that contain themselves and (2) types that contain a different
1688 // recursive type. It is only necessary to throw an error on those that
1689 // contain themselves. For case 2, there must be an inner type that will be
1690 // caught by case 1.
1691 match rty.is_representable(tcx, sp) {
1692 Representability::SelfRecursive(spans) => {
1693 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1695 err.span_label(span, "recursive without indirection");
1700 Representability::Representable | Representability::ContainsRecursive => (),
1705 pub fn check_simd<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, sp: Span, def_id: DefId) {
1706 let t = tcx.type_of(def_id);
1707 if let ty::Adt(def, substs) = t.sty {
1708 if def.is_struct() {
1709 let fields = &def.non_enum_variant().fields;
1710 if fields.is_empty() {
1711 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1714 let e = fields[0].ty(tcx, substs);
1715 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1716 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1717 .span_label(sp, "SIMD elements must have the same type")
1722 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1723 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1725 span_err!(tcx.sess, sp, E0077,
1726 "SIMD vector element type should be machine type");
1734 fn check_packed<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, sp: Span, def_id: DefId) {
1735 let repr = tcx.adt_def(def_id).repr;
1737 for attr in tcx.get_attrs(def_id).iter() {
1738 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1739 if let attr::ReprPacked(pack) = r {
1740 if pack != repr.pack {
1741 struct_span_err!(tcx.sess, sp, E0634,
1742 "type has conflicting packed representation hints").emit();
1748 struct_span_err!(tcx.sess, sp, E0587,
1749 "type has conflicting packed and align representation hints").emit();
1751 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1752 struct_span_err!(tcx.sess, sp, E0588,
1753 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1758 fn check_packed_inner<'tcx>(
1759 tcx: TyCtxt<'tcx, 'tcx>,
1761 stack: &mut Vec<DefId>,
1763 let t = tcx.type_of(def_id);
1764 if stack.contains(&def_id) {
1765 debug!("check_packed_inner: {:?} is recursive", t);
1768 if let ty::Adt(def, substs) = t.sty {
1769 if def.is_struct() || def.is_union() {
1770 if tcx.adt_def(def.did).repr.align > 0 {
1773 // push struct def_id before checking fields
1775 for field in &def.non_enum_variant().fields {
1776 let f = field.ty(tcx, substs);
1777 if let ty::Adt(def, _) = f.sty {
1778 if check_packed_inner(tcx, def.did, stack) {
1783 // only need to pop if not early out
1790 fn check_transparent<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, sp: Span, def_id: DefId) {
1791 let adt = tcx.adt_def(def_id);
1792 if !adt.repr.transparent() {
1797 if !tcx.features().transparent_enums {
1798 emit_feature_err(&tcx.sess.parse_sess,
1799 sym::transparent_enums,
1801 GateIssue::Language,
1802 "transparent enums are unstable");
1804 if adt.variants.len() != 1 {
1805 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1806 tcx.hir().span_if_local(variant.def_id).unwrap()
1808 let mut err = struct_span_err!(tcx.sess, sp, E0731,
1809 "transparent enum needs exactly one variant, but has {}",
1810 adt.variants.len());
1811 if !variant_spans.is_empty() {
1812 err.span_note(variant_spans, &format!("the following variants exist on `{}`",
1813 tcx.def_path_str(def_id)));
1816 if adt.variants.is_empty() {
1817 // Don't bother checking the fields. No variants (and thus no fields) exist.
1823 if adt.is_union() && !tcx.features().transparent_unions {
1824 emit_feature_err(&tcx.sess.parse_sess,
1825 sym::transparent_unions,
1827 GateIssue::Language,
1828 "transparent unions are unstable");
1831 // For each field, figure out if it's known to be a ZST and align(1)
1832 let field_infos = adt.all_fields().map(|field| {
1833 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1834 let param_env = tcx.param_env(field.did);
1835 let layout = tcx.layout_of(param_env.and(ty));
1836 // We are currently checking the type this field came from, so it must be local
1837 let span = tcx.hir().span_if_local(field.did).unwrap();
1838 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1839 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1843 let non_zst_fields = field_infos.clone().filter(|(_span, zst, _align1)| !*zst);
1844 let non_zst_count = non_zst_fields.clone().count();
1845 if non_zst_count != 1 {
1846 let field_spans: Vec<_> = non_zst_fields.map(|(span, _zst, _align1)| span).collect();
1848 let mut err = struct_span_err!(tcx.sess, sp, E0690,
1849 "{}transparent {} needs exactly one non-zero-sized field, but has {}",
1850 if adt.is_enum() { "the variant of a " } else { "" },
1853 if !field_spans.is_empty() {
1854 err.span_note(field_spans,
1855 &format!("the following non-zero-sized fields exist on `{}`:",
1856 tcx.def_path_str(def_id)));
1860 for (span, zst, align1) in field_infos {
1862 span_err!(tcx.sess, span, E0691,
1863 "zero-sized field in transparent {} has alignment larger than 1",
1869 #[allow(trivial_numeric_casts)]
1870 pub fn check_enum<'tcx>(
1871 tcx: TyCtxt<'tcx, 'tcx>,
1873 vs: &'tcx [hir::Variant],
1876 let def_id = tcx.hir().local_def_id_from_hir_id(id);
1877 let def = tcx.adt_def(def_id);
1878 def.destructor(tcx); // force the destructor to be evaluated
1881 let attributes = tcx.get_attrs(def_id);
1882 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1884 tcx.sess, attr.span, E0084,
1885 "unsupported representation for zero-variant enum")
1886 .span_label(sp, "zero-variant enum")
1891 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1892 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1893 if !tcx.features().repr128 {
1894 emit_feature_err(&tcx.sess.parse_sess,
1897 GateIssue::Language,
1898 "repr with 128-bit type is unstable");
1903 if let Some(ref e) = v.node.disr_expr {
1904 tcx.typeck_tables_of(tcx.hir().local_def_id_from_hir_id(e.hir_id));
1908 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1909 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1910 // Check for duplicate discriminant values
1911 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1912 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1913 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1914 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1915 let i_span = match variant_i.node.disr_expr {
1916 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1917 None => tcx.hir().span_by_hir_id(variant_i_hir_id)
1919 let span = match v.node.disr_expr {
1920 Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id),
1923 struct_span_err!(tcx.sess, span, E0081,
1924 "discriminant value `{}` already exists", disr_vals[i])
1925 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1926 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1929 disr_vals.push(discr);
1932 check_representable(tcx, sp, def_id);
1933 check_transparent(tcx, sp, def_id);
1936 fn report_unexpected_variant_res<'gcx, 'tcx>(
1937 tcx: TyCtxt<'gcx, 'tcx>,
1942 span_err!(tcx.sess, span, E0533,
1943 "expected unit struct/variant or constant, found {} `{}`",
1945 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1948 impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
1949 fn tcx<'b>(&'b self) -> TyCtxt<'gcx, 'tcx> {
1953 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
1954 -> &'tcx ty::GenericPredicates<'tcx>
1957 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
1958 let item_id = tcx.hir().ty_param_owner(hir_id);
1959 let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id);
1960 let generics = tcx.generics_of(item_def_id);
1961 let index = generics.param_def_id_to_index[&def_id];
1962 tcx.arena.alloc(ty::GenericPredicates {
1964 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
1966 ty::Predicate::Trait(ref data)
1967 if data.skip_binder().self_ty().is_param(index) => {
1968 // HACK(eddyb) should get the original `Span`.
1969 let span = tcx.def_span(def_id);
1970 Some((predicate, span))
1980 def: Option<&ty::GenericParamDef>,
1982 ) -> Option<ty::Region<'tcx>> {
1984 Some(def) => infer::EarlyBoundRegion(span, def.name),
1985 None => infer::MiscVariable(span)
1987 Some(self.next_region_var(v))
1990 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
1991 if let Some(param) = param {
1992 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
1997 self.next_ty_var(TypeVariableOrigin {
1998 kind: TypeVariableOriginKind::TypeInference,
2007 param: Option<&ty::GenericParamDef>,
2009 ) -> &'tcx Const<'tcx> {
2010 if let Some(param) = param {
2011 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2016 self.next_const_var(ty, ConstVariableOrigin {
2017 kind: ConstVariableOriginKind::ConstInference,
2023 fn projected_ty_from_poly_trait_ref(&self,
2026 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2029 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2031 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2035 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2038 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2039 if ty.has_escaping_bound_vars() {
2040 ty // FIXME: normalization and escaping regions
2042 self.normalize_associated_types_in(span, &ty)
2046 fn set_tainted_by_errors(&self) {
2047 self.infcx.set_tainted_by_errors()
2050 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2051 self.write_ty(hir_id, ty)
2055 /// Controls whether the arguments are tupled. This is used for the call
2058 /// Tupling means that all call-side arguments are packed into a tuple and
2059 /// passed as a single parameter. For example, if tupling is enabled, this
2062 /// fn f(x: (isize, isize))
2064 /// Can be called as:
2071 #[derive(Clone, Eq, PartialEq)]
2072 enum TupleArgumentsFlag {
2077 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
2078 pub fn new(inh: &'a Inherited<'a, 'gcx, 'tcx>,
2079 param_env: ty::ParamEnv<'tcx>,
2080 body_id: hir::HirId)
2081 -> FnCtxt<'a, 'gcx, 'tcx> {
2085 err_count_on_creation: inh.tcx.sess.err_count(),
2087 ret_coercion_span: RefCell::new(None),
2089 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2090 hir::CRATE_HIR_ID)),
2091 diverges: Cell::new(Diverges::Maybe),
2092 has_errors: Cell::new(false),
2093 enclosing_breakables: RefCell::new(EnclosingBreakables {
2095 by_id: Default::default(),
2101 pub fn sess(&self) -> &Session {
2105 pub fn err_count_since_creation(&self) -> usize {
2106 self.tcx.sess.err_count() - self.err_count_on_creation
2109 /// Produces warning on the given node, if the current point in the
2110 /// function is unreachable, and there hasn't been another warning.
2111 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2112 if self.diverges.get() == Diverges::Always &&
2113 // If span arose from a desugaring of `if` then it is the condition itself,
2114 // which diverges, that we are about to lint on. This gives suboptimal diagnostics
2115 // and so we stop here and allow the block of the `if`-expression to be linted instead.
2116 !span.is_compiler_desugaring(CompilerDesugaringKind::IfTemporary) {
2117 self.diverges.set(Diverges::WarnedAlways);
2119 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2121 let msg = format!("unreachable {}", kind);
2122 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2128 code: ObligationCauseCode<'tcx>)
2129 -> ObligationCause<'tcx> {
2130 ObligationCause::new(span, self.body_id, code)
2133 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2134 self.cause(span, ObligationCauseCode::MiscObligation)
2137 /// Resolves type variables in `ty` if possible. Unlike the infcx
2138 /// version (resolve_vars_if_possible), this version will
2139 /// also select obligations if it seems useful, in an effort
2140 /// to get more type information.
2141 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2142 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2144 // No Infer()? Nothing needs doing.
2145 if !ty.has_infer_types() {
2146 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2150 // If `ty` is a type variable, see whether we already know what it is.
2151 ty = self.resolve_vars_if_possible(&ty);
2152 if !ty.has_infer_types() {
2153 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2157 // If not, try resolving pending obligations as much as
2158 // possible. This can help substantially when there are
2159 // indirect dependencies that don't seem worth tracking
2161 self.select_obligations_where_possible(false);
2162 ty = self.resolve_vars_if_possible(&ty);
2164 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2168 fn record_deferred_call_resolution(&self,
2169 closure_def_id: DefId,
2170 r: DeferredCallResolution<'gcx, 'tcx>) {
2171 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2172 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2175 fn remove_deferred_call_resolutions(&self,
2176 closure_def_id: DefId)
2177 -> Vec<DeferredCallResolution<'gcx, 'tcx>>
2179 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2180 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2183 pub fn tag(&self) -> String {
2184 let self_ptr: *const FnCtxt<'_, '_, '_> = self;
2185 format!("{:?}", self_ptr)
2188 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2189 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2190 span_bug!(span, "no type for local variable {}",
2191 self.tcx.hir().hir_to_string(nid))
2196 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2197 debug!("write_ty({:?}, {:?}) in fcx {}",
2198 id, self.resolve_vars_if_possible(&ty), self.tag());
2199 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2201 if ty.references_error() {
2202 self.has_errors.set(true);
2203 self.set_tainted_by_errors();
2207 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2208 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2211 pub fn write_method_call(&self,
2213 method: MethodCallee<'tcx>) {
2214 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2217 .type_dependent_defs_mut()
2218 .insert(hir_id, Ok((DefKind::Method, method.def_id)));
2220 self.write_substs(hir_id, method.substs);
2222 // When the method is confirmed, the `method.substs` includes
2223 // parameters from not just the method, but also the impl of
2224 // the method -- in particular, the `Self` type will be fully
2225 // resolved. However, those are not something that the "user
2226 // specified" -- i.e., those types come from the inferred type
2227 // of the receiver, not something the user wrote. So when we
2228 // create the user-substs, we want to replace those earlier
2229 // types with just the types that the user actually wrote --
2230 // that is, those that appear on the *method itself*.
2232 // As an example, if the user wrote something like
2233 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2234 // type of `foo` (possibly adjusted), but we don't want to
2235 // include that. We want just the `[_, u32]` part.
2236 if !method.substs.is_noop() {
2237 let method_generics = self.tcx.generics_of(method.def_id);
2238 if !method_generics.params.is_empty() {
2239 let user_type_annotation = self.infcx.probe(|_| {
2240 let user_substs = UserSubsts {
2241 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2242 let i = param.index as usize;
2243 if i < method_generics.parent_count {
2244 self.infcx.var_for_def(DUMMY_SP, param)
2249 user_self_ty: None, // not relevant here
2252 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2258 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2259 self.write_user_type_annotation(hir_id, user_type_annotation);
2264 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2265 if !substs.is_noop() {
2266 debug!("write_substs({:?}, {:?}) in fcx {}",
2271 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2275 /// Given the substs that we just converted from the HIR, try to
2276 /// canonicalize them and store them as user-given substitutions
2277 /// (i.e., substitutions that must be respected by the NLL check).
2279 /// This should be invoked **before any unifications have
2280 /// occurred**, so that annotations like `Vec<_>` are preserved
2282 pub fn write_user_type_annotation_from_substs(
2286 substs: SubstsRef<'tcx>,
2287 user_self_ty: Option<UserSelfTy<'tcx>>,
2290 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2291 user_self_ty={:?} in fcx {}",
2292 hir_id, def_id, substs, user_self_ty, self.tag(),
2295 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2296 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2297 &UserType::TypeOf(def_id, UserSubsts {
2302 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2303 self.write_user_type_annotation(hir_id, canonicalized);
2307 pub fn write_user_type_annotation(
2310 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2313 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2314 hir_id, canonical_user_type_annotation, self.tag(),
2317 if !canonical_user_type_annotation.is_identity() {
2318 self.tables.borrow_mut().user_provided_types_mut().insert(
2319 hir_id, canonical_user_type_annotation
2322 debug!("write_user_type_annotation: skipping identity substs");
2326 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2327 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2333 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2334 Entry::Vacant(entry) => { entry.insert(adj); },
2335 Entry::Occupied(mut entry) => {
2336 debug!(" - composing on top of {:?}", entry.get());
2337 match (&entry.get()[..], &adj[..]) {
2338 // Applying any adjustment on top of a NeverToAny
2339 // is a valid NeverToAny adjustment, because it can't
2341 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2343 Adjustment { kind: Adjust::Deref(_), .. },
2344 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2346 Adjustment { kind: Adjust::Deref(_), .. },
2347 .. // Any following adjustments are allowed.
2349 // A reborrow has no effect before a dereference.
2351 // FIXME: currently we never try to compose autoderefs
2352 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2354 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2355 expr, entry.get(), adj)
2357 *entry.get_mut() = adj;
2362 /// Basically whenever we are converting from a type scheme into
2363 /// the fn body space, we always want to normalize associated
2364 /// types as well. This function combines the two.
2365 fn instantiate_type_scheme<T>(&self,
2367 substs: SubstsRef<'tcx>,
2370 where T : TypeFoldable<'tcx>
2372 let value = value.subst(self.tcx, substs);
2373 let result = self.normalize_associated_types_in(span, &value);
2374 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2381 /// As `instantiate_type_scheme`, but for the bounds found in a
2382 /// generic type scheme.
2383 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2384 -> ty::InstantiatedPredicates<'tcx> {
2385 let bounds = self.tcx.predicates_of(def_id);
2386 let result = bounds.instantiate(self.tcx, substs);
2387 let result = self.normalize_associated_types_in(span, &result);
2388 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2395 /// Replaces the opaque types from the given value with type variables,
2396 /// and records the `OpaqueTypeMap` for later use during writeback. See
2397 /// `InferCtxt::instantiate_opaque_types` for more details.
2398 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2400 parent_id: hir::HirId,
2403 let parent_def_id = self.tcx.hir().local_def_id_from_hir_id(parent_id);
2404 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2408 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2409 self.instantiate_opaque_types(
2417 let mut opaque_types = self.opaque_types.borrow_mut();
2418 for (ty, decl) in opaque_type_map {
2419 let old_value = opaque_types.insert(ty, decl);
2420 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2426 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2427 where T : TypeFoldable<'tcx>
2429 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2432 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2434 where T : TypeFoldable<'tcx>
2436 self.inh.partially_normalize_associated_types_in(span,
2442 pub fn require_type_meets(&self,
2445 code: traits::ObligationCauseCode<'tcx>,
2448 self.register_bound(
2451 traits::ObligationCause::new(span, self.body_id, code));
2454 pub fn require_type_is_sized(&self,
2457 code: traits::ObligationCauseCode<'tcx>)
2459 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2460 self.require_type_meets(ty, span, code, lang_item);
2463 pub fn require_type_is_sized_deferred(&self,
2466 code: traits::ObligationCauseCode<'tcx>)
2468 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2471 pub fn register_bound(&self,
2474 cause: traits::ObligationCause<'tcx>)
2476 self.fulfillment_cx.borrow_mut()
2477 .register_bound(self, self.param_env, ty, def_id, cause);
2480 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2481 let t = AstConv::ast_ty_to_ty(self, ast_t);
2482 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2486 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2487 let ty = self.to_ty(ast_ty);
2488 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2490 if Self::can_contain_user_lifetime_bounds(ty) {
2491 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2492 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2493 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2499 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2500 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2501 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2504 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2505 AstConv::ast_const_to_const(self, ast_c, ty)
2508 // If the type given by the user has free regions, save it for later, since
2509 // NLL would like to enforce those. Also pass in types that involve
2510 // projections, since those can resolve to `'static` bounds (modulo #54940,
2511 // which hopefully will be fixed by the time you see this comment, dear
2512 // reader, although I have my doubts). Also pass in types with inference
2513 // types, because they may be repeated. Other sorts of things are already
2514 // sufficiently enforced with erased regions. =)
2515 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2517 T: TypeFoldable<'tcx>
2519 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2522 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2523 match self.tables.borrow().node_types().get(id) {
2525 None if self.is_tainted_by_errors() => self.tcx.types.err,
2527 let node_id = self.tcx.hir().hir_to_node_id(id);
2528 bug!("no type for node {}: {} in fcx {}",
2529 node_id, self.tcx.hir().node_to_string(node_id),
2535 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2536 /// outlive the region `r`.
2537 pub fn register_wf_obligation(&self,
2540 code: traits::ObligationCauseCode<'tcx>)
2542 // WF obligations never themselves fail, so no real need to give a detailed cause:
2543 let cause = traits::ObligationCause::new(span, self.body_id, code);
2544 self.register_predicate(traits::Obligation::new(cause,
2546 ty::Predicate::WellFormed(ty)));
2549 /// Registers obligations that all types appearing in `substs` are well-formed.
2550 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2551 for ty in substs.types() {
2552 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2556 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2557 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2558 /// trait/region obligations.
2560 /// For example, if there is a function:
2563 /// fn foo<'a,T:'a>(...)
2566 /// and a reference:
2572 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2573 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2574 pub fn add_obligations_for_parameters(&self,
2575 cause: traits::ObligationCause<'tcx>,
2576 predicates: &ty::InstantiatedPredicates<'tcx>)
2578 assert!(!predicates.has_escaping_bound_vars());
2580 debug!("add_obligations_for_parameters(predicates={:?})",
2583 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2584 self.register_predicate(obligation);
2588 // FIXME(arielb1): use this instead of field.ty everywhere
2589 // Only for fields! Returns <none> for methods>
2590 // Indifferent to privacy flags
2591 pub fn field_ty(&self,
2593 field: &'tcx ty::FieldDef,
2594 substs: SubstsRef<'tcx>)
2597 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2600 fn check_casts(&self) {
2601 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2602 for cast in deferred_cast_checks.drain(..) {
2607 fn resolve_generator_interiors(&self, def_id: DefId) {
2608 let mut generators = self.deferred_generator_interiors.borrow_mut();
2609 for (body_id, interior) in generators.drain(..) {
2610 self.select_obligations_where_possible(false);
2611 generator_interior::resolve_interior(self, def_id, body_id, interior);
2615 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2616 // Non-numerics get replaced with ! or () (depending on whether
2617 // feature(never_type) is enabled, unconstrained ints with i32,
2618 // unconstrained floats with f64.
2619 // Fallback becomes very dubious if we have encountered type-checking errors.
2620 // In that case, fallback to Error.
2621 // The return value indicates whether fallback has occurred.
2622 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2623 use rustc::ty::error::UnconstrainedNumeric::Neither;
2624 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2626 assert!(ty.is_ty_infer());
2627 let fallback = match self.type_is_unconstrained_numeric(ty) {
2628 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2629 UnconstrainedInt => self.tcx.types.i32,
2630 UnconstrainedFloat => self.tcx.types.f64,
2631 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2632 Neither => return false,
2634 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2635 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2639 fn select_all_obligations_or_error(&self) {
2640 debug!("select_all_obligations_or_error");
2641 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2642 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2646 /// Select as many obligations as we can at present.
2647 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2648 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2649 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2653 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2654 /// returns a type of `&T`, but the actual type we assign to the
2655 /// *expression* is `T`. So this function just peels off the return
2656 /// type by one layer to yield `T`.
2657 fn make_overloaded_place_return_type(&self,
2658 method: MethodCallee<'tcx>)
2659 -> ty::TypeAndMut<'tcx>
2661 // extract method return type, which will be &T;
2662 let ret_ty = method.sig.output();
2664 // method returns &T, but the type as visible to user is T, so deref
2665 ret_ty.builtin_deref(true).unwrap()
2668 fn lookup_indexing(&self,
2670 base_expr: &'gcx hir::Expr,
2674 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2676 // FIXME(#18741) -- this is almost but not quite the same as the
2677 // autoderef that normal method probing does. They could likely be
2680 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2681 let mut result = None;
2682 while result.is_none() && autoderef.next().is_some() {
2683 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2685 autoderef.finalize(self);
2689 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2690 /// (and otherwise adjust) `base_expr`, looking for a type which either
2691 /// supports builtin indexing or overloaded indexing.
2692 /// This loop implements one step in that search; the autoderef loop
2693 /// is implemented by `lookup_indexing`.
2694 fn try_index_step(&self,
2696 base_expr: &hir::Expr,
2697 autoderef: &Autoderef<'a, 'gcx, 'tcx>,
2700 -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
2702 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2703 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2710 for &unsize in &[false, true] {
2711 let mut self_ty = adjusted_ty;
2713 // We only unsize arrays here.
2714 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2715 self_ty = self.tcx.mk_slice(element_ty);
2721 // If some lookup succeeds, write callee into table and extract index/element
2722 // type from the method signature.
2723 // If some lookup succeeded, install method in table
2724 let input_ty = self.next_ty_var(TypeVariableOrigin {
2725 kind: TypeVariableOriginKind::AutoDeref,
2726 span: base_expr.span,
2728 let method = self.try_overloaded_place_op(
2729 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2731 let result = method.map(|ok| {
2732 debug!("try_index_step: success, using overloaded indexing");
2733 let method = self.register_infer_ok_obligations(ok);
2735 let mut adjustments = autoderef.adjust_steps(self, needs);
2736 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2737 let mutbl = match r_mutbl {
2738 hir::MutImmutable => AutoBorrowMutability::Immutable,
2739 hir::MutMutable => AutoBorrowMutability::Mutable {
2740 // Indexing can be desugared to a method call,
2741 // so maybe we could use two-phase here.
2742 // See the documentation of AllowTwoPhase for why that's
2743 // not the case today.
2744 allow_two_phase_borrow: AllowTwoPhase::No,
2747 adjustments.push(Adjustment {
2748 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2749 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2756 adjustments.push(Adjustment {
2757 kind: Adjust::Pointer(PointerCast::Unsize),
2758 target: method.sig.inputs()[0]
2761 self.apply_adjustments(base_expr, adjustments);
2763 self.write_method_call(expr.hir_id, method);
2764 (input_ty, self.make_overloaded_place_return_type(method).ty)
2766 if result.is_some() {
2774 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2775 let (tr, name) = match (op, is_mut) {
2776 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2777 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2778 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2779 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2781 (tr, ast::Ident::with_empty_ctxt(name))
2784 fn try_overloaded_place_op(&self,
2787 arg_tys: &[Ty<'tcx>],
2790 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2792 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2798 // Try Mut first, if needed.
2799 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2800 let method = match (needs, mut_tr) {
2801 (Needs::MutPlace, Some(trait_did)) => {
2802 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2807 // Otherwise, fall back to the immutable version.
2808 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2809 let method = match (method, imm_tr) {
2810 (None, Some(trait_did)) => {
2811 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2813 (method, _) => method,
2819 fn check_method_argument_types(&self,
2822 method: Result<MethodCallee<'tcx>, ()>,
2823 args_no_rcvr: &'gcx [hir::Expr],
2824 tuple_arguments: TupleArgumentsFlag,
2825 expected: Expectation<'tcx>)
2827 let has_error = match method {
2829 method.substs.references_error() || method.sig.references_error()
2834 let err_inputs = self.err_args(args_no_rcvr.len());
2836 let err_inputs = match tuple_arguments {
2837 DontTupleArguments => err_inputs,
2838 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2841 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2842 false, tuple_arguments, None);
2843 return self.tcx.types.err;
2846 let method = method.unwrap();
2847 // HACK(eddyb) ignore self in the definition (see above).
2848 let expected_arg_tys = self.expected_inputs_for_expected_output(
2851 method.sig.output(),
2852 &method.sig.inputs()[1..]
2854 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2855 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2856 self.tcx.hir().span_if_local(method.def_id));
2860 fn self_type_matches_expected_vid(
2862 trait_ref: ty::PolyTraitRef<'tcx>,
2863 expected_vid: ty::TyVid,
2865 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2867 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2868 trait_ref, self_ty, expected_vid
2871 ty::Infer(ty::TyVar(found_vid)) => {
2872 // FIXME: consider using `sub_root_var` here so we
2873 // can see through subtyping.
2874 let found_vid = self.root_var(found_vid);
2875 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2876 expected_vid == found_vid
2882 fn obligations_for_self_ty<'b>(&'b self, self_ty: ty::TyVid)
2883 -> impl Iterator<Item=(ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2884 + Captures<'gcx> + 'b
2886 // FIXME: consider using `sub_root_var` here so we
2887 // can see through subtyping.
2888 let ty_var_root = self.root_var(self_ty);
2889 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2890 self_ty, ty_var_root,
2891 self.fulfillment_cx.borrow().pending_obligations());
2895 .pending_obligations()
2897 .filter_map(move |obligation| match obligation.predicate {
2898 ty::Predicate::Projection(ref data) =>
2899 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2900 ty::Predicate::Trait(ref data) =>
2901 Some((data.to_poly_trait_ref(), obligation)),
2902 ty::Predicate::Subtype(..) => None,
2903 ty::Predicate::RegionOutlives(..) => None,
2904 ty::Predicate::TypeOutlives(..) => None,
2905 ty::Predicate::WellFormed(..) => None,
2906 ty::Predicate::ObjectSafe(..) => None,
2907 ty::Predicate::ConstEvaluatable(..) => None,
2908 // N.B., this predicate is created by breaking down a
2909 // `ClosureType: FnFoo()` predicate, where
2910 // `ClosureType` represents some `Closure`. It can't
2911 // possibly be referring to the current closure,
2912 // because we haven't produced the `Closure` for
2913 // this closure yet; this is exactly why the other
2914 // code is looking for a self type of a unresolved
2915 // inference variable.
2916 ty::Predicate::ClosureKind(..) => None,
2917 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2920 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2921 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2922 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2926 /// Generic function that factors out common logic from function calls,
2927 /// method calls and overloaded operators.
2928 fn check_argument_types(&self,
2931 fn_inputs: &[Ty<'tcx>],
2932 expected_arg_tys: &[Ty<'tcx>],
2933 args: &'gcx [hir::Expr],
2935 tuple_arguments: TupleArgumentsFlag,
2936 def_span: Option<Span>) {
2939 // Grab the argument types, supplying fresh type variables
2940 // if the wrong number of arguments were supplied
2941 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
2947 // All the input types from the fn signature must outlive the call
2948 // so as to validate implied bounds.
2949 for &fn_input_ty in fn_inputs {
2950 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
2953 let expected_arg_count = fn_inputs.len();
2955 let param_count_error = |expected_count: usize,
2960 let mut err = tcx.sess.struct_span_err_with_code(sp,
2961 &format!("this function takes {}{} but {} {} supplied",
2962 if c_variadic { "at least " } else { "" },
2963 potentially_plural_count(expected_count, "parameter"),
2964 potentially_plural_count(arg_count, "parameter"),
2965 if arg_count == 1 {"was"} else {"were"}),
2966 DiagnosticId::Error(error_code.to_owned()));
2968 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
2969 err.span_label(def_s, "defined here");
2972 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
2973 // remove closing `)` from the span
2974 let sugg_span = sugg_span.shrink_to_lo();
2975 err.span_suggestion(
2977 "expected the unit value `()`; create it with empty parentheses",
2979 Applicability::MachineApplicable);
2981 err.span_label(sp, format!("expected {}{}",
2982 if c_variadic { "at least " } else { "" },
2983 potentially_plural_count(expected_count, "parameter")));
2988 let mut expected_arg_tys = expected_arg_tys.to_vec();
2990 let formal_tys = if tuple_arguments == TupleArguments {
2991 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
2992 match tuple_type.sty {
2993 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
2994 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
2995 expected_arg_tys = vec![];
2996 self.err_args(args.len())
2998 ty::Tuple(arg_types) => {
2999 expected_arg_tys = match expected_arg_tys.get(0) {
3000 Some(&ty) => match ty.sty {
3001 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3006 arg_types.iter().map(|k| k.expect_ty()).collect()
3009 span_err!(tcx.sess, sp, E0059,
3010 "cannot use call notation; the first type parameter \
3011 for the function trait is neither a tuple nor unit");
3012 expected_arg_tys = vec![];
3013 self.err_args(args.len())
3016 } else if expected_arg_count == supplied_arg_count {
3018 } else if c_variadic {
3019 if supplied_arg_count >= expected_arg_count {
3022 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3023 expected_arg_tys = vec![];
3024 self.err_args(supplied_arg_count)
3027 // is the missing argument of type `()`?
3028 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3029 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3030 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3031 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3035 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3037 expected_arg_tys = vec![];
3038 self.err_args(supplied_arg_count)
3041 debug!("check_argument_types: formal_tys={:?}",
3042 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3044 // If there is no expectation, expect formal_tys.
3045 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3051 // Check the arguments.
3052 // We do this in a pretty awful way: first we type-check any arguments
3053 // that are not closures, then we type-check the closures. This is so
3054 // that we have more information about the types of arguments when we
3055 // type-check the functions. This isn't really the right way to do this.
3056 for &check_closures in &[false, true] {
3057 debug!("check_closures={}", check_closures);
3059 // More awful hacks: before we check argument types, try to do
3060 // an "opportunistic" vtable resolution of any trait bounds on
3061 // the call. This helps coercions.
3063 self.select_obligations_where_possible(false);
3066 // For C-variadic functions, we don't have a declared type for all of
3067 // the arguments hence we only do our usual type checking with
3068 // the arguments who's types we do know.
3069 let t = if c_variadic {
3071 } else if tuple_arguments == TupleArguments {
3076 for (i, arg) in args.iter().take(t).enumerate() {
3077 // Warn only for the first loop (the "no closures" one).
3078 // Closure arguments themselves can't be diverging, but
3079 // a previous argument can, e.g., `foo(panic!(), || {})`.
3080 if !check_closures {
3081 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3084 let is_closure = match arg.node {
3085 ExprKind::Closure(..) => true,
3089 if is_closure != check_closures {
3093 debug!("checking the argument");
3094 let formal_ty = formal_tys[i];
3096 // The special-cased logic below has three functions:
3097 // 1. Provide as good of an expected type as possible.
3098 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3100 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3102 // 2. Coerce to the most detailed type that could be coerced
3103 // to, which is `expected_ty` if `rvalue_hint` returns an
3104 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3105 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3106 // We're processing function arguments so we definitely want to use
3107 // two-phase borrows.
3108 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3110 // 3. Relate the expected type and the formal one,
3111 // if the expected type was used for the coercion.
3112 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3116 // We also need to make sure we at least write the ty of the other
3117 // arguments which we skipped above.
3119 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3120 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3121 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3124 for arg in args.iter().skip(expected_arg_count) {
3125 let arg_ty = self.check_expr(&arg);
3127 // There are a few types which get autopromoted when passed via varargs
3128 // in C but we just error out instead and require explicit casts.
3129 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3131 ty::Float(ast::FloatTy::F32) => {
3132 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3134 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3135 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3137 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3138 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3141 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3142 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3143 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3151 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3152 vec![self.tcx.types.err; len]
3155 // AST fragment checking
3158 expected: Expectation<'tcx>)
3164 ast::LitKind::Str(..) => tcx.mk_static_str(),
3165 ast::LitKind::ByteStr(ref v) => {
3166 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3167 tcx.mk_array(tcx.types.u8, v.len() as u64))
3169 ast::LitKind::Byte(_) => tcx.types.u8,
3170 ast::LitKind::Char(_) => tcx.types.char,
3171 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3172 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3173 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3174 let opt_ty = expected.to_option(self).and_then(|ty| {
3176 ty::Int(_) | ty::Uint(_) => Some(ty),
3177 ty::Char => Some(tcx.types.u8),
3178 ty::RawPtr(..) => Some(tcx.types.usize),
3179 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3183 opt_ty.unwrap_or_else(|| self.next_int_var())
3185 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3186 ast::LitKind::FloatUnsuffixed(_) => {
3187 let opt_ty = expected.to_option(self).and_then(|ty| {
3189 ty::Float(_) => Some(ty),
3193 opt_ty.unwrap_or_else(|| self.next_float_var())
3195 ast::LitKind::Bool(_) => tcx.types.bool,
3196 ast::LitKind::Err(_) => tcx.types.err,
3200 fn check_expr_eq_type(&self,
3201 expr: &'gcx hir::Expr,
3202 expected: Ty<'tcx>) {
3203 let ty = self.check_expr_with_hint(expr, expected);
3204 self.demand_eqtype(expr.span, expected, ty);
3207 pub fn check_expr_has_type_or_error(&self,
3208 expr: &'gcx hir::Expr,
3209 expected: Ty<'tcx>) -> Ty<'tcx> {
3210 self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected))
3213 fn check_expr_meets_expectation_or_error(&self,
3214 expr: &'gcx hir::Expr,
3215 expected: Expectation<'tcx>) -> Ty<'tcx> {
3216 let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
3217 let mut ty = self.check_expr_with_expectation(expr, expected);
3219 // While we don't allow *arbitrary* coercions here, we *do* allow
3220 // coercions from ! to `expected`.
3222 assert!(!self.tables.borrow().adjustments().contains_key(expr.hir_id),
3223 "expression with never type wound up being adjusted");
3224 let adj_ty = self.next_diverging_ty_var(
3225 TypeVariableOrigin {
3226 kind: TypeVariableOriginKind::AdjustmentType,
3230 self.apply_adjustments(expr, vec![Adjustment {
3231 kind: Adjust::NeverToAny,
3237 if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
3238 let expr = match &expr.node {
3239 ExprKind::DropTemps(expr) => expr,
3242 // Error possibly reported in `check_assign` so avoid emitting error again.
3243 err.emit_unless(self.is_assign_to_bool(expr, expected_ty));
3248 fn check_expr_coercable_to_type(&self,
3249 expr: &'gcx hir::Expr,
3250 expected: Ty<'tcx>) -> Ty<'tcx> {
3251 let ty = self.check_expr_with_hint(expr, expected);
3252 // checks don't need two phase
3253 self.demand_coerce(expr, ty, expected, AllowTwoPhase::No)
3256 fn check_expr_with_hint(&self,
3257 expr: &'gcx hir::Expr,
3258 expected: Ty<'tcx>) -> Ty<'tcx> {
3259 self.check_expr_with_expectation(expr, ExpectHasType(expected))
3262 fn check_expr_with_expectation(&self,
3263 expr: &'gcx hir::Expr,
3264 expected: Expectation<'tcx>) -> Ty<'tcx> {
3265 self.check_expr_with_expectation_and_needs(expr, expected, Needs::None)
3268 fn check_expr(&self, expr: &'gcx hir::Expr) -> Ty<'tcx> {
3269 self.check_expr_with_expectation(expr, NoExpectation)
3272 fn check_expr_with_needs(&self, expr: &'gcx hir::Expr, needs: Needs) -> Ty<'tcx> {
3273 self.check_expr_with_expectation_and_needs(expr, NoExpectation, needs)
3276 // Determine the `Self` type, using fresh variables for all variables
3277 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3278 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3280 pub fn impl_self_ty(&self,
3281 span: Span, // (potential) receiver for this impl
3283 -> TypeAndSubsts<'tcx> {
3284 let ity = self.tcx.type_of(did);
3285 debug!("impl_self_ty: ity={:?}", ity);
3287 let substs = self.fresh_substs_for_item(span, did);
3288 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3290 TypeAndSubsts { substs: substs, ty: substd_ty }
3293 /// Unifies the output type with the expected type early, for more coercions
3294 /// and forward type information on the input expressions.
3295 fn expected_inputs_for_expected_output(&self,
3297 expected_ret: Expectation<'tcx>,
3298 formal_ret: Ty<'tcx>,
3299 formal_args: &[Ty<'tcx>])
3301 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3302 let ret_ty = match expected_ret.only_has_type(self) {
3304 None => return Vec::new()
3306 let expect_args = self.fudge_inference_if_ok(|| {
3307 // Attempt to apply a subtyping relationship between the formal
3308 // return type (likely containing type variables if the function
3309 // is polymorphic) and the expected return type.
3310 // No argument expectations are produced if unification fails.
3311 let origin = self.misc(call_span);
3312 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3314 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3315 // to identity so the resulting type is not constrained.
3318 // Process any obligations locally as much as
3319 // we can. We don't care if some things turn
3320 // out unconstrained or ambiguous, as we're
3321 // just trying to get hints here.
3322 self.save_and_restore_in_snapshot_flag(|_| {
3323 let mut fulfill = TraitEngine::new(self.tcx);
3324 for obligation in ok.obligations {
3325 fulfill.register_predicate_obligation(self, obligation);
3327 fulfill.select_where_possible(self)
3328 }).map_err(|_| ())?;
3330 Err(_) => return Err(()),
3333 // Record all the argument types, with the substitutions
3334 // produced from the above subtyping unification.
3335 Ok(formal_args.iter().map(|ty| {
3336 self.resolve_vars_if_possible(ty)
3338 }).unwrap_or_default();
3339 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3340 formal_args, formal_ret,
3341 expect_args, expected_ret);
3345 // Checks a method call.
3346 fn check_method_call(&self,
3347 expr: &'gcx hir::Expr,
3348 segment: &hir::PathSegment,
3350 args: &'gcx [hir::Expr],
3351 expected: Expectation<'tcx>,
3352 needs: Needs) -> Ty<'tcx> {
3353 let rcvr = &args[0];
3354 let rcvr_t = self.check_expr_with_needs(&rcvr, needs);
3355 // no need to check for bot/err -- callee does that
3356 let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
3358 let method = match self.lookup_method(rcvr_t,
3364 self.write_method_call(expr.hir_id, method);
3368 if segment.ident.name != kw::Invalid {
3369 self.report_method_error(span,
3372 SelfSource::MethodCall(rcvr),
3380 // Call the generic checker.
3381 self.check_method_argument_types(span,
3389 fn check_return_expr(&self, return_expr: &'gcx hir::Expr) {
3393 .unwrap_or_else(|| span_bug!(return_expr.span,
3394 "check_return_expr called outside fn body"));
3396 let ret_ty = ret_coercion.borrow().expected_ty();
3397 let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty.clone());
3398 ret_coercion.borrow_mut()
3400 &self.cause(return_expr.span,
3401 ObligationCauseCode::ReturnType(return_expr.hir_id)),
3406 // Check field access expressions
3407 fn check_field(&self,
3408 expr: &'gcx hir::Expr,
3410 base: &'gcx hir::Expr,
3411 field: ast::Ident) -> Ty<'tcx> {
3412 let expr_t = self.check_expr_with_needs(base, needs);
3413 let expr_t = self.structurally_resolved_type(base.span,
3415 let mut private_candidate = None;
3416 let mut autoderef = self.autoderef(expr.span, expr_t);
3417 while let Some((base_t, _)) = autoderef.next() {
3419 ty::Adt(base_def, substs) if !base_def.is_enum() => {
3420 debug!("struct named {:?}", base_t);
3421 let (ident, def_scope) =
3422 self.tcx.adjust_ident_and_get_scope(field, base_def.did, self.body_id);
3423 let fields = &base_def.non_enum_variant().fields;
3424 if let Some(index) = fields.iter().position(|f| f.ident.modern() == ident) {
3425 let field = &fields[index];
3426 let field_ty = self.field_ty(expr.span, field, substs);
3427 // Save the index of all fields regardless of their visibility in case
3428 // of error recovery.
3429 self.write_field_index(expr.hir_id, index);
3430 if field.vis.is_accessible_from(def_scope, self.tcx) {
3431 let adjustments = autoderef.adjust_steps(self, needs);
3432 self.apply_adjustments(base, adjustments);
3433 autoderef.finalize(self);
3435 self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
3438 private_candidate = Some((base_def.did, field_ty));
3441 ty::Tuple(ref tys) => {
3442 let fstr = field.as_str();
3443 if let Ok(index) = fstr.parse::<usize>() {
3444 if fstr == index.to_string() {
3445 if let Some(field_ty) = tys.get(index) {
3446 let adjustments = autoderef.adjust_steps(self, needs);
3447 self.apply_adjustments(base, adjustments);
3448 autoderef.finalize(self);
3450 self.write_field_index(expr.hir_id, index);
3451 return field_ty.expect_ty();
3459 autoderef.unambiguous_final_ty(self);
3461 if let Some((did, field_ty)) = private_candidate {
3462 let struct_path = self.tcx().def_path_str(did);
3463 let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
3464 "field `{}` of struct `{}` is private",
3465 field, struct_path);
3466 // Also check if an accessible method exists, which is often what is meant.
3467 if self.method_exists(field, expr_t, expr.hir_id, false)
3468 && !self.expr_in_place(expr.hir_id)
3470 self.suggest_method_call(
3472 &format!("a method `{}` also exists, call it with parentheses", field),
3480 } else if field.name == kw::Invalid {
3481 self.tcx().types.err
3482 } else if self.method_exists(field, expr_t, expr.hir_id, true) {
3483 let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
3484 "attempted to take value of method `{}` on type `{}`",
3487 if !self.expr_in_place(expr.hir_id) {
3488 self.suggest_method_call(
3490 "use parentheses to call the method",
3496 err.help("methods are immutable and cannot be assigned to");
3500 self.tcx().types.err
3502 if !expr_t.is_primitive_ty() {
3503 let mut err = self.no_such_field_err(field.span, field, expr_t);
3506 ty::Adt(def, _) if !def.is_enum() => {
3507 if let Some(suggested_field_name) =
3508 Self::suggest_field_name(def.non_enum_variant(),
3509 &field.as_str(), vec![]) {
3510 err.span_suggestion(
3512 "a field with a similar name exists",
3513 suggested_field_name.to_string(),
3514 Applicability::MaybeIncorrect,
3517 err.span_label(field.span, "unknown field");
3518 let struct_variant_def = def.non_enum_variant();
3519 let field_names = self.available_field_names(struct_variant_def);
3520 if !field_names.is_empty() {
3521 err.note(&format!("available fields are: {}",
3522 self.name_series_display(field_names)));
3526 ty::Array(_, len) => {
3527 if let (Some(len), Ok(user_index)) = (
3528 len.assert_usize(self.tcx),
3529 field.as_str().parse::<u64>()
3531 let base = self.tcx.sess.source_map()
3532 .span_to_snippet(base.span)
3534 self.tcx.hir().hir_to_pretty_string(base.hir_id));
3535 let help = "instead of using tuple indexing, use array indexing";
3536 let suggestion = format!("{}[{}]", base, field);
3537 let applicability = if len < user_index {
3538 Applicability::MachineApplicable
3540 Applicability::MaybeIncorrect
3542 err.span_suggestion(
3543 expr.span, help, suggestion, applicability
3548 let base = self.tcx.sess.source_map()
3549 .span_to_snippet(base.span)
3550 .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
3551 let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
3552 let suggestion = format!("(*{}).{}", base, field);
3553 err.span_suggestion(
3557 Applicability::MaybeIncorrect,
3564 type_error_struct!(self.tcx().sess, field.span, expr_t, E0610,
3565 "`{}` is a primitive type and therefore doesn't have fields",
3568 self.tcx().types.err
3572 // Return an hint about the closest match in field names
3573 fn suggest_field_name(variant: &'tcx ty::VariantDef,
3575 skip: Vec<LocalInternedString>)
3577 let names = variant.fields.iter().filter_map(|field| {
3578 // ignore already set fields and private fields from non-local crates
3579 if skip.iter().any(|x| *x == field.ident.as_str()) ||
3580 (!variant.def_id.is_local() && field.vis != Visibility::Public)
3584 Some(&field.ident.name)
3588 find_best_match_for_name(names, field, None)
3591 fn available_field_names(&self, variant: &'tcx ty::VariantDef) -> Vec<ast::Name> {
3592 variant.fields.iter().filter(|field| {
3594 self.tcx.adjust_ident_and_get_scope(field.ident, variant.def_id, self.body_id).1;
3595 field.vis.is_accessible_from(def_scope, self.tcx)
3597 .map(|field| field.ident.name)
3601 fn name_series_display(&self, names: Vec<ast::Name>) -> String {
3602 // dynamic limit, to never omit just one field
3603 let limit = if names.len() == 6 { 6 } else { 5 };
3604 let mut display = names.iter().take(limit)
3605 .map(|n| format!("`{}`", n)).collect::<Vec<_>>().join(", ");
3606 if names.len() > limit {
3607 display = format!("{} ... and {} others", display, names.len() - limit);
3612 fn no_such_field_err<T: Display>(&self, span: Span, field: T, expr_t: &ty::TyS<'_>)
3613 -> DiagnosticBuilder<'_> {
3614 type_error_struct!(self.tcx().sess, span, expr_t, E0609,
3615 "no field `{}` on type `{}`",
3619 fn report_unknown_field(
3622 variant: &'tcx ty::VariantDef,
3624 skip_fields: &[hir::Field],
3627 if variant.recovered {
3630 let mut err = self.type_error_struct_with_diag(
3632 |actual| match ty.sty {
3633 ty::Adt(adt, ..) if adt.is_enum() => {
3634 struct_span_err!(self.tcx.sess, field.ident.span, E0559,
3635 "{} `{}::{}` has no field named `{}`",
3636 kind_name, actual, variant.ident, field.ident)
3639 struct_span_err!(self.tcx.sess, field.ident.span, E0560,
3640 "{} `{}` has no field named `{}`",
3641 kind_name, actual, field.ident)
3645 // prevent all specified fields from being suggested
3646 let skip_fields = skip_fields.iter().map(|ref x| x.ident.as_str());
3647 if let Some(field_name) = Self::suggest_field_name(variant,
3648 &field.ident.as_str(),
3649 skip_fields.collect()) {
3650 err.span_suggestion(
3652 "a field with a similar name exists",
3653 field_name.to_string(),
3654 Applicability::MaybeIncorrect,
3658 ty::Adt(adt, ..) => {
3660 err.span_label(field.ident.span,
3661 format!("`{}::{}` does not have this field",
3662 ty, variant.ident));
3664 err.span_label(field.ident.span,
3665 format!("`{}` does not have this field", ty));
3667 let available_field_names = self.available_field_names(variant);
3668 if !available_field_names.is_empty() {
3669 err.note(&format!("available fields are: {}",
3670 self.name_series_display(available_field_names)));
3673 _ => bug!("non-ADT passed to report_unknown_field")
3679 fn check_expr_struct_fields(&self,
3681 expected: Expectation<'tcx>,
3682 expr_id: hir::HirId,
3684 variant: &'tcx ty::VariantDef,
3685 ast_fields: &'gcx [hir::Field],
3686 check_completeness: bool) -> bool {
3690 self.expected_inputs_for_expected_output(span, expected, adt_ty, &[adt_ty])
3691 .get(0).cloned().unwrap_or(adt_ty);
3692 // re-link the regions that EIfEO can erase.
3693 self.demand_eqtype(span, adt_ty_hint, adt_ty);
3695 let (substs, adt_kind, kind_name) = match &adt_ty.sty {
3696 &ty::Adt(adt, substs) => {
3697 (substs, adt.adt_kind(), adt.variant_descr())
3699 _ => span_bug!(span, "non-ADT passed to check_expr_struct_fields")
3702 let mut remaining_fields = variant.fields.iter().enumerate().map(|(i, field)|
3703 (field.ident.modern(), (i, field))
3704 ).collect::<FxHashMap<_, _>>();
3706 let mut seen_fields = FxHashMap::default();
3708 let mut error_happened = false;
3710 // Type-check each field.
3711 for field in ast_fields {
3712 let ident = tcx.adjust_ident(field.ident, variant.def_id);
3713 let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
3714 seen_fields.insert(ident, field.span);
3715 self.write_field_index(field.hir_id, i);
3717 // We don't look at stability attributes on
3718 // struct-like enums (yet...), but it's definitely not
3719 // a bug to have constructed one.
3720 if adt_kind != AdtKind::Enum {
3721 tcx.check_stability(v_field.did, Some(expr_id), field.span);
3724 self.field_ty(field.span, v_field, substs)
3726 error_happened = true;
3727 if let Some(prev_span) = seen_fields.get(&ident) {
3728 let mut err = struct_span_err!(self.tcx.sess,
3731 "field `{}` specified more than once",
3734 err.span_label(field.ident.span, "used more than once");
3735 err.span_label(*prev_span, format!("first use of `{}`", ident));
3739 self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name);
3745 // Make sure to give a type to the field even if there's
3746 // an error, so we can continue type-checking.
3747 self.check_expr_coercable_to_type(&field.expr, field_type);
3750 // Make sure the programmer specified correct number of fields.
3751 if kind_name == "union" {
3752 if ast_fields.len() != 1 {
3753 tcx.sess.span_err(span, "union expressions should have exactly one field");
3755 } else if check_completeness && !error_happened && !remaining_fields.is_empty() {
3756 let len = remaining_fields.len();
3758 let mut displayable_field_names = remaining_fields
3760 .map(|ident| ident.as_str())
3761 .collect::<Vec<_>>();
3763 displayable_field_names.sort();
3765 let truncated_fields_error = if len <= 3 {
3768 format!(" and {} other field{}", (len - 3), if len - 3 == 1 {""} else {"s"})
3771 let remaining_fields_names = displayable_field_names.iter().take(3)
3772 .map(|n| format!("`{}`", n))
3773 .collect::<Vec<_>>()
3776 struct_span_err!(tcx.sess, span, E0063,
3777 "missing field{} {}{} in initializer of `{}`",
3778 if remaining_fields.len() == 1 { "" } else { "s" },
3779 remaining_fields_names,
3780 truncated_fields_error,
3782 .span_label(span, format!("missing {}{}",
3783 remaining_fields_names,
3784 truncated_fields_error))
3790 fn check_struct_fields_on_error(&self,
3791 fields: &'gcx [hir::Field],
3792 base_expr: &'gcx Option<P<hir::Expr>>) {
3793 for field in fields {
3794 self.check_expr(&field.expr);
3796 if let Some(ref base) = *base_expr {
3797 self.check_expr(&base);
3801 pub fn check_struct_path(&self,
3804 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3805 let path_span = match *qpath {
3806 QPath::Resolved(_, ref path) => path.span,
3807 QPath::TypeRelative(ref qself, _) => qself.span
3809 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3810 let variant = match def {
3812 self.set_tainted_by_errors();
3815 Res::Def(DefKind::Variant, _) => {
3817 ty::Adt(adt, substs) => {
3818 Some((adt.variant_of_res(def), adt.did, substs))
3820 _ => bug!("unexpected type: {:?}", ty)
3823 Res::Def(DefKind::Struct, _)
3824 | Res::Def(DefKind::Union, _)
3825 | Res::Def(DefKind::TyAlias, _)
3826 | Res::Def(DefKind::AssocTy, _)
3827 | Res::SelfTy(..) => {
3829 ty::Adt(adt, substs) if !adt.is_enum() => {
3830 Some((adt.non_enum_variant(), adt.did, substs))
3835 _ => bug!("unexpected definition: {:?}", def)
3838 if let Some((variant, did, substs)) = variant {
3839 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3840 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3842 // Check bounds on type arguments used in the path.
3843 let bounds = self.instantiate_bounds(path_span, did, substs);
3844 let cause = traits::ObligationCause::new(path_span, self.body_id,
3845 traits::ItemObligation(did));
3846 self.add_obligations_for_parameters(cause, &bounds);
3850 struct_span_err!(self.tcx.sess, path_span, E0071,
3851 "expected struct, variant or union type, found {}",
3852 ty.sort_string(self.tcx))
3853 .span_label(path_span, "not a struct")
3859 fn check_expr_struct(&self,
3861 expected: Expectation<'tcx>,
3863 fields: &'gcx [hir::Field],
3864 base_expr: &'gcx Option<P<hir::Expr>>) -> Ty<'tcx>
3866 // Find the relevant variant
3867 let (variant, adt_ty) =
3868 if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
3871 self.check_struct_fields_on_error(fields, base_expr);
3872 return self.tcx.types.err;
3875 let path_span = match *qpath {
3876 QPath::Resolved(_, ref path) => path.span,
3877 QPath::TypeRelative(ref qself, _) => qself.span
3880 // Prohibit struct expressions when non-exhaustive flag is set.
3881 let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
3882 if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
3883 span_err!(self.tcx.sess, expr.span, E0639,
3884 "cannot create non-exhaustive {} using struct expression",
3885 adt.variant_descr());
3888 let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
3889 variant, fields, base_expr.is_none());
3890 if let &Some(ref base_expr) = base_expr {
3891 // If check_expr_struct_fields hit an error, do not attempt to populate
3892 // the fields with the base_expr. This could cause us to hit errors later
3893 // when certain fields are assumed to exist that in fact do not.
3894 if !error_happened {
3895 self.check_expr_has_type_or_error(base_expr, adt_ty);
3897 ty::Adt(adt, substs) if adt.is_struct() => {
3898 let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
3899 self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
3904 .fru_field_types_mut()
3905 .insert(expr.hir_id, fru_field_types);
3908 span_err!(self.tcx.sess, base_expr.span, E0436,
3909 "functional record update syntax requires a struct");
3914 self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
3920 /// If an expression has any sub-expressions that result in a type error,
3921 /// inspecting that expression's type with `ty.references_error()` will return
3922 /// true. Likewise, if an expression is known to diverge, inspecting its
3923 /// type with `ty::type_is_bot` will return true (n.b.: since Rust is
3924 /// strict, _|_ can appear in the type of an expression that does not,
3925 /// itself, diverge: for example, fn() -> _|_.)
3926 /// Note that inspecting a type's structure *directly* may expose the fact
3927 /// that there are actually multiple representations for `Error`, so avoid
3928 /// that when err needs to be handled differently.
3929 fn check_expr_with_expectation_and_needs(&self,
3930 expr: &'gcx hir::Expr,
3931 expected: Expectation<'tcx>,
3932 needs: Needs) -> Ty<'tcx> {
3933 debug!(">> type-checking: expr={:?} expected={:?}",
3936 // Warn for expressions after diverging siblings.
3937 self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
3939 // Hide the outer diverging and has_errors flags.
3940 let old_diverges = self.diverges.get();
3941 let old_has_errors = self.has_errors.get();
3942 self.diverges.set(Diverges::Maybe);
3943 self.has_errors.set(false);
3945 let ty = self.check_expr_kind(expr, expected, needs);
3947 // Warn for non-block expressions with diverging children.
3949 ExprKind::Block(..) |
3950 ExprKind::Loop(..) | ExprKind::While(..) |
3951 ExprKind::Match(..) => {}
3953 _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
3956 // Any expression that produces a value of type `!` must have diverged
3958 self.diverges.set(self.diverges.get() | Diverges::Always);
3961 // Record the type, which applies it effects.
3962 // We need to do this after the warning above, so that
3963 // we don't warn for the diverging expression itself.
3964 self.write_ty(expr.hir_id, ty);
3966 // Combine the diverging and has_error flags.
3967 self.diverges.set(self.diverges.get() | old_diverges);
3968 self.has_errors.set(self.has_errors.get() | old_has_errors);
3970 debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
3971 debug!("... {:?}, expected is {:?}", ty, expected);
3978 expr: &'gcx hir::Expr,
3979 expected: Expectation<'tcx>,
3983 "check_expr_kind(expr={:?}, expected={:?}, needs={:?})",
3990 let id = expr.hir_id;
3992 ExprKind::Box(ref subexpr) => {
3993 let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
3995 ty::Adt(def, _) if def.is_box()
3996 => Expectation::rvalue_hint(self, ty.boxed_ty()),
4000 let referent_ty = self.check_expr_with_expectation(subexpr, expected_inner);
4001 tcx.mk_box(referent_ty)
4004 ExprKind::Lit(ref lit) => {
4005 self.check_lit(&lit, expected)
4007 ExprKind::Binary(op, ref lhs, ref rhs) => {
4008 self.check_binop(expr, op, lhs, rhs)
4010 ExprKind::AssignOp(op, ref lhs, ref rhs) => {
4011 self.check_binop_assign(expr, op, lhs, rhs)
4013 ExprKind::Unary(unop, ref oprnd) => {
4014 let expected_inner = match unop {
4015 hir::UnNot | hir::UnNeg => {
4022 let needs = match unop {
4023 hir::UnDeref => needs,
4026 let mut oprnd_t = self.check_expr_with_expectation_and_needs(&oprnd,
4030 if !oprnd_t.references_error() {
4031 oprnd_t = self.structurally_resolved_type(expr.span, oprnd_t);
4034 if let Some(mt) = oprnd_t.builtin_deref(true) {
4036 } else if let Some(ok) = self.try_overloaded_deref(
4037 expr.span, oprnd_t, needs) {
4038 let method = self.register_infer_ok_obligations(ok);
4039 if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].sty {
4040 let mutbl = match mutbl {
4041 hir::MutImmutable => AutoBorrowMutability::Immutable,
4042 hir::MutMutable => AutoBorrowMutability::Mutable {
4043 // (It shouldn't actually matter for unary ops whether
4044 // we enable two-phase borrows or not, since a unary
4045 // op has no additional operands.)
4046 allow_two_phase_borrow: AllowTwoPhase::No,
4049 self.apply_adjustments(oprnd, vec![Adjustment {
4050 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
4051 target: method.sig.inputs()[0]
4054 oprnd_t = self.make_overloaded_place_return_type(method).ty;
4055 self.write_method_call(expr.hir_id, method);
4057 let mut err = type_error_struct!(
4062 "type `{}` cannot be dereferenced",
4065 let sp = tcx.sess.source_map().start_point(expr.span);
4066 if let Some(sp) = tcx.sess.parse_sess.ambiguous_block_expr_parse
4069 tcx.sess.parse_sess.expr_parentheses_needed(
4076 oprnd_t = tcx.types.err;
4080 let result = self.check_user_unop(expr, oprnd_t, unop);
4081 // If it's builtin, we can reuse the type, this helps inference.
4082 if !(oprnd_t.is_integral() || oprnd_t.sty == ty::Bool) {
4087 let result = self.check_user_unop(expr, oprnd_t, unop);
4088 // If it's builtin, we can reuse the type, this helps inference.
4089 if !oprnd_t.is_numeric() {
4097 ExprKind::AddrOf(mutbl, ref oprnd) => {
4098 let hint = expected.only_has_type(self).map_or(NoExpectation, |ty| {
4100 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
4101 if oprnd.is_place_expr() {
4102 // Places may legitimately have unsized types.
4103 // For example, dereferences of a fat pointer and
4104 // the last field of a struct can be unsized.
4107 Expectation::rvalue_hint(self, ty)
4113 let needs = Needs::maybe_mut_place(mutbl);
4114 let ty = self.check_expr_with_expectation_and_needs(&oprnd, hint, needs);
4116 let tm = ty::TypeAndMut { ty: ty, mutbl: mutbl };
4117 if tm.ty.references_error() {
4120 // Note: at this point, we cannot say what the best lifetime
4121 // is to use for resulting pointer. We want to use the
4122 // shortest lifetime possible so as to avoid spurious borrowck
4123 // errors. Moreover, the longest lifetime will depend on the
4124 // precise details of the value whose address is being taken
4125 // (and how long it is valid), which we don't know yet until type
4126 // inference is complete.
4128 // Therefore, here we simply generate a region variable. The
4129 // region inferencer will then select the ultimate value.
4130 // Finally, borrowck is charged with guaranteeing that the
4131 // value whose address was taken can actually be made to live
4132 // as long as it needs to live.
4133 let region = self.next_region_var(infer::AddrOfRegion(expr.span));
4134 tcx.mk_ref(region, tm)
4137 ExprKind::Path(ref qpath) => {
4138 let (res, opt_ty, segs) = self.resolve_ty_and_res_ufcs(qpath, expr.hir_id,
4140 let ty = match res {
4142 self.set_tainted_by_errors();
4145 Res::Def(DefKind::Ctor(_, CtorKind::Fictive), _) => {
4146 report_unexpected_variant_res(tcx, res, expr.span, qpath);
4149 _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, id).0,
4152 if let ty::FnDef(..) = ty.sty {
4153 let fn_sig = ty.fn_sig(tcx);
4154 if !tcx.features().unsized_locals {
4155 // We want to remove some Sized bounds from std functions,
4156 // but don't want to expose the removal to stable Rust.
4157 // i.e., we don't want to allow
4163 // to work in stable even if the Sized bound on `drop` is relaxed.
4164 for i in 0..fn_sig.inputs().skip_binder().len() {
4165 // We just want to check sizedness, so instead of introducing
4166 // placeholder lifetimes with probing, we just replace higher lifetimes
4168 let input = self.replace_bound_vars_with_fresh_vars(
4170 infer::LateBoundRegionConversionTime::FnCall,
4171 &fn_sig.input(i)).0;
4172 self.require_type_is_sized_deferred(input, expr.span,
4173 traits::SizedArgumentType);
4176 // Here we want to prevent struct constructors from returning unsized types.
4177 // There were two cases this happened: fn pointer coercion in stable
4178 // and usual function call in presense of unsized_locals.
4179 // Also, as we just want to check sizedness, instead of introducing
4180 // placeholder lifetimes with probing, we just replace higher lifetimes
4182 let output = self.replace_bound_vars_with_fresh_vars(
4184 infer::LateBoundRegionConversionTime::FnCall,
4185 &fn_sig.output()).0;
4186 self.require_type_is_sized_deferred(output, expr.span, traits::SizedReturnType);
4189 // We always require that the type provided as the value for
4190 // a type parameter outlives the moment of instantiation.
4191 let substs = self.tables.borrow().node_substs(expr.hir_id);
4192 self.add_wf_bounds(substs, expr);
4196 ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
4197 for expr in outputs.iter().chain(inputs.iter()) {
4198 self.check_expr(expr);
4202 ExprKind::Break(destination, ref expr_opt) => {
4203 if let Ok(target_id) = destination.target_id {
4205 if let Some(ref e) = *expr_opt {
4206 // If this is a break with a value, we need to type-check
4207 // the expression. Get an expected type from the loop context.
4208 let opt_coerce_to = {
4209 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4210 enclosing_breakables.find_breakable(target_id)
4213 .map(|coerce| coerce.expected_ty())
4216 // If the loop context is not a `loop { }`, then break with
4217 // a value is illegal, and `opt_coerce_to` will be `None`.
4218 // Just set expectation to error in that case.
4219 let coerce_to = opt_coerce_to.unwrap_or(tcx.types.err);
4221 // Recurse without `enclosing_breakables` borrowed.
4222 e_ty = self.check_expr_with_hint(e, coerce_to);
4223 cause = self.misc(e.span);
4225 // Otherwise, this is a break *without* a value. That's
4226 // always legal, and is equivalent to `break ()`.
4227 e_ty = tcx.mk_unit();
4228 cause = self.misc(expr.span);
4231 // Now that we have type-checked `expr_opt`, borrow
4232 // the `enclosing_loops` field and let's coerce the
4233 // type of `expr_opt` into what is expected.
4234 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4235 let ctxt = enclosing_breakables.find_breakable(target_id);
4236 if let Some(ref mut coerce) = ctxt.coerce {
4237 if let Some(ref e) = *expr_opt {
4238 coerce.coerce(self, &cause, e, e_ty);
4240 assert!(e_ty.is_unit());
4241 coerce.coerce_forced_unit(self, &cause, &mut |_| (), true);
4244 // If `ctxt.coerce` is `None`, we can just ignore
4245 // the type of the expresison. This is because
4246 // either this was a break *without* a value, in
4247 // which case it is always a legal type (`()`), or
4248 // else an error would have been flagged by the
4249 // `loops` pass for using break with an expression
4250 // where you are not supposed to.
4251 assert!(expr_opt.is_none() || self.tcx.sess.err_count() > 0);
4254 ctxt.may_break = true;
4256 // the type of a `break` is always `!`, since it diverges
4259 // Otherwise, we failed to find the enclosing loop;
4260 // this can only happen if the `break` was not
4261 // inside a loop at all, which is caught by the
4262 // loop-checking pass.
4263 if self.tcx.sess.err_count() == 0 {
4264 self.tcx.sess.delay_span_bug(expr.span,
4265 "break was outside loop, but no error was emitted");
4268 // We still need to assign a type to the inner expression to
4269 // prevent the ICE in #43162.
4270 if let Some(ref e) = *expr_opt {
4271 self.check_expr_with_hint(e, tcx.types.err);
4273 // ... except when we try to 'break rust;'.
4274 // ICE this expression in particular (see #43162).
4275 if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node {
4276 if path.segments.len() == 1 &&
4277 path.segments[0].ident.name == sym::rust {
4278 fatally_break_rust(self.tcx.sess);
4282 // There was an error; make type-check fail.
4287 ExprKind::Continue(destination) => {
4288 if destination.target_id.is_ok() {
4291 // There was an error; make type-check fail.
4295 ExprKind::Ret(ref expr_opt) => {
4296 if self.ret_coercion.is_none() {
4297 struct_span_err!(self.tcx.sess, expr.span, E0572,
4298 "return statement outside of function body").emit();
4299 } else if let Some(ref e) = *expr_opt {
4300 if self.ret_coercion_span.borrow().is_none() {
4301 *self.ret_coercion_span.borrow_mut() = Some(e.span);
4303 self.check_return_expr(e);
4305 let mut coercion = self.ret_coercion.as_ref().unwrap().borrow_mut();
4306 if self.ret_coercion_span.borrow().is_none() {
4307 *self.ret_coercion_span.borrow_mut() = Some(expr.span);
4309 let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
4310 if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
4311 coercion.coerce_forced_unit(
4316 fn_decl.output.span(),
4318 "expected `{}` because of this return type",
4326 coercion.coerce_forced_unit(self, &cause, &mut |_| (), true);
4331 ExprKind::Assign(ref lhs, ref rhs) => {
4332 self.check_assign(expr, expected, lhs, rhs)
4334 ExprKind::While(ref cond, ref body, _) => {
4335 let ctxt = BreakableCtxt {
4336 // cannot use break with a value from a while loop
4338 may_break: false, // Will get updated if/when we find a `break`.
4341 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4342 self.check_expr_has_type_or_error(&cond, tcx.types.bool);
4343 let cond_diverging = self.diverges.get();
4344 self.check_block_no_value(&body);
4346 // We may never reach the body so it diverging means nothing.
4347 self.diverges.set(cond_diverging);
4351 // No way to know whether it's diverging because
4352 // of a `break` or an outer `break` or `return`.
4353 self.diverges.set(Diverges::Maybe);
4358 ExprKind::Loop(ref body, _, source) => {
4359 let coerce = match source {
4360 // you can only use break with a value from a normal `loop { }`
4361 hir::LoopSource::Loop => {
4362 let coerce_to = expected.coercion_target_type(self, body.span);
4363 Some(CoerceMany::new(coerce_to))
4366 hir::LoopSource::WhileLet |
4367 hir::LoopSource::ForLoop => {
4372 let ctxt = BreakableCtxt {
4374 may_break: false, // Will get updated if/when we find a `break`.
4377 let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
4378 self.check_block_no_value(&body);
4382 // No way to know whether it's diverging because
4383 // of a `break` or an outer `break` or `return`.
4384 self.diverges.set(Diverges::Maybe);
4387 // If we permit break with a value, then result type is
4388 // the LUB of the breaks (possibly ! if none); else, it
4389 // is nil. This makes sense because infinite loops
4390 // (which would have type !) are only possible iff we
4391 // permit break with a value [1].
4392 if ctxt.coerce.is_none() && !ctxt.may_break {
4394 self.tcx.sess.delay_span_bug(body.span, "no coercion, but loop may not break");
4396 ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| self.tcx.mk_unit())
4398 ExprKind::Match(ref discrim, ref arms, match_src) => {
4399 self.check_match(expr, &discrim, arms, expected, match_src)
4401 ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
4402 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
4404 ExprKind::Block(ref body, _) => {
4405 self.check_block_with_expected(&body, expected)
4407 ExprKind::Call(ref callee, ref args) => {
4408 self.check_call(expr, &callee, args, expected)
4410 ExprKind::MethodCall(ref segment, span, ref args) => {
4411 self.check_method_call(expr, segment, span, args, expected, needs)
4413 ExprKind::Cast(ref e, ref t) => {
4414 // Find the type of `e`. Supply hints based on the type we are casting to,
4416 let t_cast = self.to_ty_saving_user_provided_ty(t);
4417 let t_cast = self.resolve_vars_if_possible(&t_cast);
4418 let t_expr = self.check_expr_with_expectation(e, ExpectCastableToType(t_cast));
4419 let t_cast = self.resolve_vars_if_possible(&t_cast);
4421 // Eagerly check for some obvious errors.
4422 if t_expr.references_error() || t_cast.references_error() {
4425 // Defer other checks until we're done type checking.
4426 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
4427 match cast::CastCheck::new(self, e, t_expr, t_cast, t.span, expr.span) {
4429 deferred_cast_checks.push(cast_check);
4432 Err(ErrorReported) => {
4438 ExprKind::Type(ref e, ref t) => {
4439 let ty = self.to_ty_saving_user_provided_ty(&t);
4440 self.check_expr_eq_type(&e, ty);
4443 ExprKind::DropTemps(ref e) => {
4444 self.check_expr_with_expectation(e, expected)
4446 ExprKind::Array(ref args) => {
4447 let uty = expected.to_option(self).and_then(|uty| {
4449 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4454 let element_ty = if !args.is_empty() {
4455 let coerce_to = uty.unwrap_or_else(|| {
4456 self.next_ty_var(TypeVariableOrigin {
4457 kind: TypeVariableOriginKind::TypeInference,
4461 let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
4462 assert_eq!(self.diverges.get(), Diverges::Maybe);
4464 let e_ty = self.check_expr_with_hint(e, coerce_to);
4465 let cause = self.misc(e.span);
4466 coerce.coerce(self, &cause, e, e_ty);
4468 coerce.complete(self)
4470 self.next_ty_var(TypeVariableOrigin {
4471 kind: TypeVariableOriginKind::TypeInference,
4475 tcx.mk_array(element_ty, args.len() as u64)
4477 ExprKind::Repeat(ref element, ref count) => {
4478 let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id);
4479 let count = if self.const_param_def_id(count).is_some() {
4480 Ok(self.to_const(count, self.tcx.type_of(count_def_id)))
4482 let param_env = ty::ParamEnv::empty();
4483 let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id);
4484 let instance = ty::Instance::resolve(
4490 let global_id = GlobalId {
4495 tcx.const_eval(param_env.and(global_id))
4498 let uty = match expected {
4499 ExpectHasType(uty) => {
4501 ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
4508 let (element_ty, t) = match uty {
4510 self.check_expr_coercable_to_type(&element, uty);
4514 let ty = self.next_ty_var(TypeVariableOrigin {
4515 kind: TypeVariableOriginKind::MiscVariable,
4518 let element_ty = self.check_expr_has_type_or_error(&element, ty);
4523 if let Ok(count) = count {
4524 let zero_or_one = count.assert_usize(tcx).map_or(false, |count| count <= 1);
4526 // For [foo, ..n] where n > 1, `foo` must have
4528 let lang_item = self.tcx.require_lang_item(lang_items::CopyTraitLangItem);
4529 self.require_type_meets(t, expr.span, traits::RepeatVec, lang_item);
4533 if element_ty.references_error() {
4535 } else if let Ok(count) = count {
4536 tcx.mk_ty(ty::Array(t, count))
4541 ExprKind::Tup(ref elts) => {
4542 let flds = expected.only_has_type(self).and_then(|ty| {
4543 let ty = self.resolve_type_vars_with_obligations(ty);
4545 ty::Tuple(ref flds) => Some(&flds[..]),
4550 let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| {
4551 let t = match flds {
4552 Some(ref fs) if i < fs.len() => {
4553 let ety = fs[i].expect_ty();
4554 self.check_expr_coercable_to_type(&e, ety);
4558 self.check_expr_with_expectation(&e, NoExpectation)
4563 let tuple = tcx.mk_tup(elt_ts_iter);
4564 if tuple.references_error() {
4567 self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
4571 ExprKind::Struct(ref qpath, ref fields, ref base_expr) => {
4572 self.check_expr_struct(expr, expected, qpath, fields, base_expr)
4574 ExprKind::Field(ref base, field) => {
4575 self.check_field(expr, needs, &base, field)
4577 ExprKind::Index(ref base, ref idx) => {
4578 let base_t = self.check_expr_with_needs(&base, needs);
4579 let idx_t = self.check_expr(&idx);
4581 if base_t.references_error() {
4583 } else if idx_t.references_error() {
4586 let base_t = self.structurally_resolved_type(base.span, base_t);
4587 match self.lookup_indexing(expr, base, base_t, idx_t, needs) {
4588 Some((index_ty, element_ty)) => {
4589 // two-phase not needed because index_ty is never mutable
4590 self.demand_coerce(idx, idx_t, index_ty, AllowTwoPhase::No);
4595 type_error_struct!(tcx.sess, expr.span, base_t, E0608,
4596 "cannot index into a value of type `{}`",
4598 // Try to give some advice about indexing tuples.
4599 if let ty::Tuple(..) = base_t.sty {
4600 let mut needs_note = true;
4601 // If the index is an integer, we can show the actual
4602 // fixed expression:
4603 if let ExprKind::Lit(ref lit) = idx.node {
4604 if let ast::LitKind::Int(i,
4605 ast::LitIntType::Unsuffixed) = lit.node {
4606 let snip = tcx.sess.source_map().span_to_snippet(base.span);
4607 if let Ok(snip) = snip {
4608 err.span_suggestion(
4610 "to access tuple elements, use",
4611 format!("{}.{}", snip, i),
4612 Applicability::MachineApplicable,
4619 err.help("to access tuple elements, use tuple indexing \
4620 syntax (e.g., `tuple.0`)");
4629 ExprKind::Yield(ref value) => {
4630 match self.yield_ty {
4632 self.check_expr_coercable_to_type(&value, ty);
4635 struct_span_err!(self.tcx.sess, expr.span, E0627,
4636 "yield statement outside of generator literal").emit();
4641 hir::ExprKind::Err => {
4647 /// Type check assignment expression `expr` of form `lhs = rhs`.
4648 /// The expected type is `()` and is passsed to the function for the purposes of diagnostics.
4651 expr: &'gcx hir::Expr,
4652 expected: Expectation<'tcx>,
4653 lhs: &'gcx hir::Expr,
4654 rhs: &'gcx hir::Expr,
4656 let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
4657 let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty);
4659 let expected_ty = expected.coercion_target_type(self, expr.span);
4660 if expected_ty == self.tcx.types.bool {
4661 // The expected type is `bool` but this will result in `()` so we can reasonably
4662 // say that the user intended to write `lhs == rhs` instead of `lhs = rhs`.
4663 // The likely cause of this is `if foo = bar { .. }`.
4664 let actual_ty = self.tcx.mk_unit();
4665 let mut err = self.demand_suptype_diag(expr.span, expected_ty, actual_ty).unwrap();
4666 let msg = "try comparing for equality";
4667 let left = self.tcx.sess.source_map().span_to_snippet(lhs.span);
4668 let right = self.tcx.sess.source_map().span_to_snippet(rhs.span);
4669 if let (Ok(left), Ok(right)) = (left, right) {
4670 let help = format!("{} == {}", left, right);
4671 err.span_suggestion(expr.span, msg, help, Applicability::MaybeIncorrect);
4676 } else if !lhs.is_place_expr() {
4677 struct_span_err!(self.tcx.sess, expr.span, E0070,
4678 "invalid left-hand side expression")
4679 .span_label(expr.span, "left-hand of expression not valid")
4683 self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
4685 if lhs_ty.references_error() || rhs_ty.references_error() {
4692 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4693 // The newly resolved definition is written into `type_dependent_defs`.
4694 fn finish_resolving_struct_path(&self,
4701 QPath::Resolved(ref maybe_qself, ref path) => {
4702 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4703 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4706 QPath::TypeRelative(ref qself, ref segment) => {
4707 let ty = self.to_ty(qself);
4709 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
4714 let result = AstConv::associated_path_to_ty(
4723 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4724 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4726 // Write back the new resolution.
4727 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4729 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4734 /// Resolves associated value path into a base type and associated constant or method
4735 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4736 pub fn resolve_ty_and_res_ufcs<'b>(&self,
4740 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
4742 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4743 let (ty, qself, item_segment) = match *qpath {
4744 QPath::Resolved(ref opt_qself, ref path) => {
4746 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4747 &path.segments[..]);
4749 QPath::TypeRelative(ref qself, ref segment) => {
4750 (self.to_ty(qself), qself, segment)
4753 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4754 // Return directly on cache hit. This is useful to avoid doubly reporting
4755 // errors with default match binding modes. See #44614.
4756 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
4757 .unwrap_or(Res::Err);
4758 return (def, Some(ty), slice::from_ref(&**item_segment));
4760 let item_name = item_segment.ident;
4761 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4762 let result = match error {
4763 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4764 _ => Err(ErrorReported),
4766 if item_name.name != kw::Invalid {
4767 self.report_method_error(
4771 SelfSource::QPath(qself),
4779 // Write back the new resolution.
4780 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, result);
4782 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4784 slice::from_ref(&**item_segment),
4788 pub fn check_decl_initializer(&self,
4789 local: &'gcx hir::Local,
4790 init: &'gcx hir::Expr) -> Ty<'tcx>
4792 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4793 // for #42640 (default match binding modes).
4796 let ref_bindings = local.pat.contains_explicit_ref_binding();
4798 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4799 if let Some(m) = ref_bindings {
4800 // Somewhat subtle: if we have a `ref` binding in the pattern,
4801 // we want to avoid introducing coercions for the RHS. This is
4802 // both because it helps preserve sanity and, in the case of
4803 // ref mut, for soundness (issue #23116). In particular, in
4804 // the latter case, we need to be clear that the type of the
4805 // referent for the reference that results is *equal to* the
4806 // type of the place it is referencing, and not some
4807 // supertype thereof.
4808 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4809 self.demand_eqtype(init.span, local_ty, init_ty);
4812 self.check_expr_coercable_to_type(init, local_ty)
4816 pub fn check_decl_local(&self, local: &'gcx hir::Local) {
4817 let t = self.local_ty(local.span, local.hir_id).decl_ty;
4818 self.write_ty(local.hir_id, t);
4820 if let Some(ref init) = local.init {
4821 let init_ty = self.check_decl_initializer(local, &init);
4822 if init_ty.references_error() {
4823 self.write_ty(local.hir_id, init_ty);
4827 self.check_pat_walk(
4830 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
4833 let pat_ty = self.node_ty(local.pat.hir_id);
4834 if pat_ty.references_error() {
4835 self.write_ty(local.hir_id, pat_ty);
4839 pub fn check_stmt(&self, stmt: &'gcx hir::Stmt) {
4840 // Don't do all the complex logic below for `DeclItem`.
4842 hir::StmtKind::Item(..) => return,
4843 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4846 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4848 // Hide the outer diverging and `has_errors` flags.
4849 let old_diverges = self.diverges.get();
4850 let old_has_errors = self.has_errors.get();
4851 self.diverges.set(Diverges::Maybe);
4852 self.has_errors.set(false);
4855 hir::StmtKind::Local(ref l) => {
4856 self.check_decl_local(&l);
4859 hir::StmtKind::Item(_) => {}
4860 hir::StmtKind::Expr(ref expr) => {
4861 // Check with expected type of `()`.
4862 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
4864 hir::StmtKind::Semi(ref expr) => {
4865 self.check_expr(&expr);
4869 // Combine the diverging and `has_error` flags.
4870 self.diverges.set(self.diverges.get() | old_diverges);
4871 self.has_errors.set(self.has_errors.get() | old_has_errors);
4874 pub fn check_block_no_value(&self, blk: &'gcx hir::Block) {
4875 let unit = self.tcx.mk_unit();
4876 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4878 // if the block produces a `!` value, that can always be
4879 // (effectively) coerced to unit.
4881 self.demand_suptype(blk.span, unit, ty);
4885 fn check_block_with_expected(&self,
4886 blk: &'gcx hir::Block,
4887 expected: Expectation<'tcx>) -> Ty<'tcx> {
4889 let mut fcx_ps = self.ps.borrow_mut();
4890 let unsafety_state = fcx_ps.recurse(blk);
4891 replace(&mut *fcx_ps, unsafety_state)
4894 // In some cases, blocks have just one exit, but other blocks
4895 // can be targeted by multiple breaks. This can happen both
4896 // with labeled blocks as well as when we desugar
4897 // a `try { ... }` expression.
4901 // 'a: { if true { break 'a Err(()); } Ok(()) }
4903 // Here we would wind up with two coercions, one from
4904 // `Err(())` and the other from the tail expression
4905 // `Ok(())`. If the tail expression is omitted, that's a
4906 // "forced unit" -- unless the block diverges, in which
4907 // case we can ignore the tail expression (e.g., `'a: {
4908 // break 'a 22; }` would not force the type of the block
4910 let tail_expr = blk.expr.as_ref();
4911 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4912 let coerce = if blk.targeted_by_break {
4913 CoerceMany::new(coerce_to_ty)
4915 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4916 Some(e) => slice::from_ref(e),
4919 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4922 let prev_diverges = self.diverges.get();
4923 let ctxt = BreakableCtxt {
4924 coerce: Some(coerce),
4928 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4929 for s in &blk.stmts {
4933 // check the tail expression **without** holding the
4934 // `enclosing_breakables` lock below.
4935 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4937 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4938 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4939 let coerce = ctxt.coerce.as_mut().unwrap();
4940 if let Some(tail_expr_ty) = tail_expr_ty {
4941 let tail_expr = tail_expr.unwrap();
4942 let cause = self.cause(tail_expr.span,
4943 ObligationCauseCode::BlockTailExpression(blk.hir_id));
4949 // Subtle: if there is no explicit tail expression,
4950 // that is typically equivalent to a tail expression
4951 // of `()` -- except if the block diverges. In that
4952 // case, there is no value supplied from the tail
4953 // expression (assuming there are no other breaks,
4954 // this implies that the type of the block will be
4957 // #41425 -- label the implicit `()` as being the
4958 // "found type" here, rather than the "expected type".
4959 if !self.diverges.get().always() {
4960 // #50009 -- Do not point at the entire fn block span, point at the return type
4961 // span, as it is the cause of the requirement, and
4962 // `consider_hint_about_removing_semicolon` will point at the last expression
4963 // if it were a relevant part of the error. This improves usability in editors
4964 // that highlight errors inline.
4965 let mut sp = blk.span;
4966 let mut fn_span = None;
4967 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4968 let ret_sp = decl.output.span();
4969 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4970 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4971 // output would otherwise be incorrect and even misleading. Make sure
4972 // the span we're aiming at correspond to a `fn` body.
4973 if block_sp == blk.span {
4975 fn_span = Some(ident.span);
4979 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4980 if let Some(expected_ty) = expected.only_has_type(self) {
4981 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4983 if let Some(fn_span) = fn_span {
4984 err.span_label(fn_span, "this function's body doesn't return");
4992 // If we can break from the block, then the block's exit is always reachable
4993 // (... as long as the entry is reachable) - regardless of the tail of the block.
4994 self.diverges.set(prev_diverges);
4997 let mut ty = ctxt.coerce.unwrap().complete(self);
4999 if self.has_errors.get() || ty.references_error() {
5000 ty = self.tcx.types.err
5003 self.write_ty(blk.hir_id, ty);
5005 *self.ps.borrow_mut() = prev;
5009 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
5010 let node = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(id));
5012 Node::Item(&hir::Item {
5013 node: hir::ItemKind::Fn(_, _, _, body_id), ..
5015 Node::ImplItem(&hir::ImplItem {
5016 node: hir::ImplItemKind::Method(_, body_id), ..
5018 let body = self.tcx.hir().body(body_id);
5019 if let ExprKind::Block(block, _) = &body.value.node {
5020 return Some(block.span);
5028 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
5029 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, ast::Ident)> {
5030 let parent = self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_item(blk_id));
5031 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
5034 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
5035 fn get_node_fn_decl(&self, node: Node<'_>) -> Option<(hir::FnDecl, ast::Ident, bool)> {
5037 Node::Item(&hir::Item {
5038 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
5039 }) => decl.clone().and_then(|decl| {
5040 // This is less than ideal, it will not suggest a return type span on any
5041 // method called `main`, regardless of whether it is actually the entry point,
5042 // but it will still present it as the reason for the expected type.
5043 Some((decl, ident, ident.name != sym::main))
5045 Node::TraitItem(&hir::TraitItem {
5046 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
5049 }) => decl.clone().and_then(|decl| Some((decl, ident, true))),
5050 Node::ImplItem(&hir::ImplItem {
5051 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
5054 }) => decl.clone().and_then(|decl| Some((decl, ident, false))),
5059 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
5060 /// suggestion can be made, `None` otherwise.
5061 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
5062 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
5063 // `while` before reaching it, as block tail returns are not available in them.
5064 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
5065 let parent = self.tcx.hir().get_by_hir_id(blk_id);
5066 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
5070 /// On implicit return expressions with mismatched types, provides the following suggestions:
5072 /// - Points out the method's return type as the reason for the expected type.
5073 /// - Possible missing semicolon.
5074 /// - Possible missing return type if the return type is the default, and not `fn main()`.
5075 pub fn suggest_mismatched_types_on_tail(
5077 err: &mut DiagnosticBuilder<'tcx>,
5078 expression: &'gcx hir::Expr,
5084 self.suggest_missing_semicolon(err, expression, expected, cause_span);
5085 let mut pointing_at_return_type = false;
5086 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
5087 pointing_at_return_type = self.suggest_missing_return_type(
5088 err, &fn_decl, expected, found, can_suggest);
5090 self.suggest_ref_or_into(err, expression, expected, found);
5091 pointing_at_return_type
5094 pub fn suggest_ref_or_into(
5096 err: &mut DiagnosticBuilder<'tcx>,
5101 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5102 err.span_suggestion(
5106 Applicability::MachineApplicable,
5108 } else if !self.check_for_cast(err, expr, found, expected) {
5109 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
5113 let methods = self.get_conversion_methods(expr.span, expected, found);
5114 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5115 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
5116 .filter_map(|(receiver, method)| {
5117 let method_call = format!(".{}()", method.ident);
5118 if receiver.ends_with(&method_call) {
5119 None // do not suggest code that is already there (#53348)
5121 let method_call_list = [".to_vec()", ".to_string()"];
5122 let sugg = if receiver.ends_with(".clone()")
5123 && method_call_list.contains(&method_call.as_str()) {
5124 let max_len = receiver.rfind(".").unwrap();
5125 format!("{}{}", &receiver[..max_len], method_call)
5127 format!("{}{}", receiver, method_call)
5129 Some(if is_struct_pat_shorthand_field {
5130 format!("{}: {}", receiver, sugg)
5136 if suggestions.peek().is_some() {
5137 err.span_suggestions(
5139 "try using a conversion method",
5141 Applicability::MaybeIncorrect,
5148 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5152 /// bar_that_returns_u32()
5156 /// This routine checks if the return expression in a block would make sense on its own as a
5157 /// statement and the return type has been left as default or has been specified as `()`. If so,
5158 /// it suggests adding a semicolon.
5159 fn suggest_missing_semicolon(&self,
5160 err: &mut DiagnosticBuilder<'tcx>,
5161 expression: &'gcx hir::Expr,
5164 if expected.is_unit() {
5165 // `BlockTailExpression` only relevant if the tail expr would be
5166 // useful on its own.
5167 match expression.node {
5168 ExprKind::Call(..) |
5169 ExprKind::MethodCall(..) |
5170 ExprKind::While(..) |
5171 ExprKind::Loop(..) |
5172 ExprKind::Match(..) |
5173 ExprKind::Block(..) => {
5174 let sp = self.tcx.sess.source_map().next_point(cause_span);
5175 err.span_suggestion(
5177 "try adding a semicolon",
5179 Applicability::MachineApplicable);
5186 /// A possible error is to forget to add a return type that is needed:
5190 /// bar_that_returns_u32()
5194 /// This routine checks if the return type is left as default, the method is not part of an
5195 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5197 fn suggest_missing_return_type(
5199 err: &mut DiagnosticBuilder<'tcx>,
5200 fn_decl: &hir::FnDecl,
5205 // Only suggest changing the return type for methods that
5206 // haven't set a return type at all (and aren't `fn main()` or an impl).
5207 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5208 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5209 err.span_suggestion(
5211 "try adding a return type",
5212 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
5213 Applicability::MachineApplicable);
5216 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5217 err.span_label(span, "possibly return type missing here?");
5220 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5221 // `fn main()` must return `()`, do not suggest changing return type
5222 err.span_label(span, "expected `()` because of default return type");
5225 // expectation was caused by something else, not the default return
5226 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5227 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5228 // Only point to return type if the expected type is the return type, as if they
5229 // are not, the expectation must have been caused by something else.
5230 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
5232 let ty = AstConv::ast_ty_to_ty(self, ty);
5233 debug!("suggest_missing_return_type: return type {:?}", ty);
5234 debug!("suggest_missing_return_type: expected type {:?}", ty);
5235 if ty.sty == expected.sty {
5236 err.span_label(sp, format!("expected `{}` because of return type",
5245 /// A common error is to add an extra semicolon:
5248 /// fn foo() -> usize {
5253 /// This routine checks if the final statement in a block is an
5254 /// expression with an explicit semicolon whose type is compatible
5255 /// with `expected_ty`. If so, it suggests removing the semicolon.
5256 fn consider_hint_about_removing_semicolon(
5258 blk: &'gcx hir::Block,
5259 expected_ty: Ty<'tcx>,
5260 err: &mut DiagnosticBuilder<'_>,
5262 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5263 err.span_suggestion(
5265 "consider removing this semicolon",
5267 Applicability::MachineApplicable,
5272 fn could_remove_semicolon(
5274 blk: &'gcx hir::Block,
5275 expected_ty: Ty<'tcx>,
5277 // Be helpful when the user wrote `{... expr;}` and
5278 // taking the `;` off is enough to fix the error.
5279 let last_stmt = blk.stmts.last()?;
5280 let last_expr = match last_stmt.node {
5281 hir::StmtKind::Semi(ref e) => e,
5284 let last_expr_ty = self.node_ty(last_expr.hir_id);
5285 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5288 let original_span = original_sp(last_stmt.span, blk.span);
5289 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5292 // Rewrite `SelfCtor` to `Ctor`
5293 pub fn rewrite_self_ctor(
5297 ) -> Result<Res, ErrorReported> {
5299 if let Res::SelfCtor(impl_def_id) = res {
5300 let ty = self.impl_self_ty(span, impl_def_id).ty;
5301 let adt_def = ty.ty_adt_def();
5304 Some(adt_def) if adt_def.has_ctor() => {
5305 let variant = adt_def.non_enum_variant();
5306 let ctor_def_id = variant.ctor_def_id.unwrap();
5307 Ok(Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id))
5310 let mut err = tcx.sess.struct_span_err(span,
5311 "the `Self` constructor can only be used with tuple or unit structs");
5312 if let Some(adt_def) = adt_def {
5313 match adt_def.adt_kind() {
5315 err.help("did you mean to use one of the enum's variants?");
5319 err.span_suggestion(
5321 "use curly brackets",
5322 String::from("Self { /* fields */ }"),
5323 Applicability::HasPlaceholders,
5338 // Instantiates the given path, which must refer to an item with the given
5339 // number of type parameters and type.
5340 pub fn instantiate_value_path(&self,
5341 segments: &[hir::PathSegment],
5342 self_ty: Option<Ty<'tcx>>,
5346 -> (Ty<'tcx>, Res) {
5348 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5357 let res = match self.rewrite_self_ctor(res, span) {
5359 Err(ErrorReported) => return (tcx.types.err, res),
5361 let path_segs = match res {
5362 Res::Local(_) => vec![],
5363 Res::Def(kind, def_id) =>
5364 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
5365 _ => bug!("instantiate_value_path on {:?}", res),
5368 let mut user_self_ty = None;
5369 let mut is_alias_variant_ctor = false;
5371 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5372 if let Some(self_ty) = self_ty {
5373 let adt_def = self_ty.ty_adt_def().unwrap();
5374 user_self_ty = Some(UserSelfTy {
5375 impl_def_id: adt_def.did,
5378 is_alias_variant_ctor = true;
5381 Res::Def(DefKind::Method, def_id)
5382 | Res::Def(DefKind::AssocConst, def_id) => {
5383 let container = tcx.associated_item(def_id).container;
5384 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5386 ty::TraitContainer(trait_did) => {
5387 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5389 ty::ImplContainer(impl_def_id) => {
5390 if segments.len() == 1 {
5391 // `<T>::assoc` will end up here, and so
5392 // can `T::assoc`. It this came from an
5393 // inherent impl, we need to record the
5394 // `T` for posterity (see `UserSelfTy` for
5396 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5397 user_self_ty = Some(UserSelfTy {
5408 // Now that we have categorized what space the parameters for each
5409 // segment belong to, let's sort out the parameters that the user
5410 // provided (if any) into their appropriate spaces. We'll also report
5411 // errors if type parameters are provided in an inappropriate place.
5413 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5414 let generics_has_err = AstConv::prohibit_generics(
5415 self, segments.iter().enumerate().filter_map(|(index, seg)| {
5416 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5423 if let Res::Local(hid) = res {
5424 let ty = self.local_ty(span, hid).decl_ty;
5425 let ty = self.normalize_associated_types_in(span, &ty);
5426 self.write_ty(hir_id, ty);
5430 if generics_has_err {
5431 // Don't try to infer type parameters when prohibited generic arguments were given.
5432 user_self_ty = None;
5435 // Now we have to compare the types that the user *actually*
5436 // provided against the types that were *expected*. If the user
5437 // did not provide any types, then we want to substitute inference
5438 // variables. If the user provided some types, we may still need
5439 // to add defaults. If the user provided *too many* types, that's
5442 let mut infer_args_for_err = FxHashSet::default();
5443 for &PathSeg(def_id, index) in &path_segs {
5444 let seg = &segments[index];
5445 let generics = tcx.generics_of(def_id);
5446 // Argument-position `impl Trait` is treated as a normal generic
5447 // parameter internally, but we don't allow users to specify the
5448 // parameter's value explicitly, so we have to do some error-
5450 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5455 false, // `is_method_call`
5457 if suppress_errors {
5458 infer_args_for_err.insert(index);
5459 self.set_tainted_by_errors(); // See issue #53251.
5463 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
5464 tcx.generics_of(*def_id).has_self
5465 }).unwrap_or(false);
5467 let def_id = res.def_id();
5469 // The things we are substituting into the type should not contain
5470 // escaping late-bound regions, and nor should the base type scheme.
5471 let ty = tcx.type_of(def_id);
5473 let substs = AstConv::create_substs_for_generic_args(
5479 // Provide the generic args, and whether types should be inferred.
5481 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
5484 // If we've encountered an `impl Trait`-related error, we're just
5485 // going to infer the arguments for better error messages.
5486 if !infer_args_for_err.contains(&index) {
5487 // Check whether the user has provided generic arguments.
5488 if let Some(ref data) = segments[index].args {
5489 return (Some(data), segments[index].infer_args);
5492 return (None, segments[index].infer_args);
5497 // Provide substitutions for parameters for which (valid) arguments have been provided.
5499 match (¶m.kind, arg) {
5500 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5501 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5503 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5504 self.to_ty(ty).into()
5506 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5507 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5509 _ => unreachable!(),
5512 // Provide substitutions for parameters for which arguments are inferred.
5513 |substs, param, infer_args| {
5515 GenericParamDefKind::Lifetime => {
5516 self.re_infer(Some(param), span).unwrap().into()
5518 GenericParamDefKind::Type { has_default, .. } => {
5519 if !infer_args && has_default {
5520 // If we have a default, then we it doesn't matter that we're not
5521 // inferring the type arguments: we provide the default where any
5523 let default = tcx.type_of(param.def_id);
5526 default.subst_spanned(tcx, substs.unwrap(), Some(span))
5529 // If no type arguments were provided, we have to infer them.
5530 // This case also occurs as a result of some malformed input, e.g.
5531 // a lifetime argument being given instead of a type parameter.
5532 // Using inference instead of `Error` gives better error messages.
5533 self.var_for_def(span, param)
5536 GenericParamDefKind::Const => {
5537 // FIXME(const_generics:defaults)
5538 // No const parameters were provided, we have to infer them.
5539 self.var_for_def(span, param)
5544 assert!(!substs.has_escaping_bound_vars());
5545 assert!(!ty.has_escaping_bound_vars());
5547 // First, store the "user substs" for later.
5548 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5550 // Add all the obligations that are required, substituting and
5551 // normalized appropriately.
5552 let bounds = self.instantiate_bounds(span, def_id, &substs);
5553 self.add_obligations_for_parameters(
5554 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5557 // Substitute the values for the type parameters into the type of
5558 // the referenced item.
5559 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5561 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5562 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5563 // is inherent, there is no `Self` parameter; instead, the impl needs
5564 // type parameters, which we can infer by unifying the provided `Self`
5565 // with the substituted impl type.
5566 // This also occurs for an enum variant on a type alias.
5567 let ty = tcx.type_of(impl_def_id);
5569 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5570 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5571 Ok(ok) => self.register_infer_ok_obligations(ok),
5573 self.tcx.sess.delay_span_bug(span, &format!(
5574 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5582 self.check_rustc_args_require_const(def_id, hir_id, span);
5584 debug!("instantiate_value_path: type of {:?} is {:?}",
5587 self.write_substs(hir_id, substs);
5589 (ty_substituted, res)
5592 fn check_rustc_args_require_const(&self,
5596 // We're only interested in functions tagged with
5597 // #[rustc_args_required_const], so ignore anything that's not.
5598 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5602 // If our calling expression is indeed the function itself, we're good!
5603 // If not, generate an error that this can only be called directly.
5604 if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
5605 self.tcx.hir().get_parent_node_by_hir_id(hir_id))
5607 if let ExprKind::Call(ref callee, ..) = expr.node {
5608 if callee.hir_id == hir_id {
5614 self.tcx.sess.span_err(span, "this function can only be invoked \
5615 directly, not through a function pointer");
5618 // Resolves `typ` by a single level if `typ` is a type variable.
5619 // If no resolution is possible, then an error is reported.
5620 // Numeric inference variables may be left unresolved.
5621 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5622 let ty = self.resolve_type_vars_with_obligations(ty);
5623 if !ty.is_ty_var() {
5626 if !self.is_tainted_by_errors() {
5627 self.need_type_info_err((**self).body_id, sp, ty)
5628 .note("type must be known at this point")
5631 self.demand_suptype(sp, self.tcx.types.err, ty);
5636 fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
5637 ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
5638 -> (BreakableCtxt<'gcx, 'tcx>, R) {
5641 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5642 index = enclosing_breakables.stack.len();
5643 enclosing_breakables.by_id.insert(id, index);
5644 enclosing_breakables.stack.push(ctxt);
5648 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5649 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5650 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5651 enclosing_breakables.stack.pop().expect("missing breakable context")
5656 /// Instantiate a QueryResponse in a probe context, without a
5657 /// good ObligationCause.
5658 fn probe_instantiate_query_response(
5661 original_values: &OriginalQueryValues<'tcx>,
5662 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5663 ) -> InferResult<'tcx, Ty<'tcx>>
5665 self.instantiate_query_response_and_region_obligations(
5666 &traits::ObligationCause::misc(span, self.body_id),
5672 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5673 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5674 let mut contained_in_place = false;
5676 while let hir::Node::Expr(parent_expr) =
5677 self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
5679 match &parent_expr.node {
5680 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5681 if lhs.hir_id == expr_id {
5682 contained_in_place = true;
5688 expr_id = parent_expr.hir_id;
5695 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5696 let own_counts = generics.own_counts();
5698 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5704 if own_counts.types == 0 {
5708 // Make a vector of booleans initially false, set to true when used.
5709 let mut types_used = vec![false; own_counts.types];
5711 for leaf_ty in ty.walk() {
5712 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
5713 debug!("Found use of ty param num {}", index);
5714 types_used[index as usize - own_counts.lifetimes] = true;
5715 } else if let ty::Error = leaf_ty.sty {
5716 // If there is already another error, do not emit
5717 // an error for not using a type Parameter.
5718 assert!(tcx.sess.err_count() > 0);
5723 let types = generics.params.iter().filter(|param| match param.kind {
5724 ty::GenericParamDefKind::Type { .. } => true,
5727 for (&used, param) in types_used.iter().zip(types) {
5729 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5730 let span = tcx.hir().span_by_hir_id(id);
5731 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5732 .span_label(span, "unused type parameter")
5738 fn fatally_break_rust(sess: &Session) {
5739 let handler = sess.diagnostic();
5740 handler.span_bug_no_panic(
5742 "It looks like you're trying to break rust; would you like some ICE?",
5744 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5745 handler.note_without_error(
5746 "we would appreciate a joke overview: \
5747 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5749 handler.note_without_error(&format!("rustc {} running on {}",
5750 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5751 crate::session::config::host_triple(),
5755 fn potentially_plural_count(count: usize, word: &str) -> String {
5756 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })