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
86 mod generator_interior;
90 use crate::astconv::{AstConv, PathSeg};
91 use errors::{Applicability, DiagnosticBuilder, DiagnosticId, pluralise};
92 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
93 use rustc::hir::def::{CtorOf, Res, DefKind};
94 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
95 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
96 use rustc::hir::itemlikevisit::ItemLikeVisitor;
97 use rustc::hir::ptr::P;
98 use crate::middle::lang_items;
99 use crate::namespace::Namespace;
100 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
101 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
102 use rustc_data_structures::indexed_vec::Idx;
103 use rustc_target::spec::abi::Abi;
104 use rustc::infer::opaque_types::OpaqueTypeDecl;
105 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
106 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
107 use rustc::middle::region;
108 use rustc::mir::interpret::{ConstValue, GlobalId};
109 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
111 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
112 ToPolyTraitRef, ToPredicate, RegionKind, UserType
114 use rustc::ty::adjustment::{
115 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
117 use rustc::ty::fold::TypeFoldable;
118 use rustc::ty::query::Providers;
119 use rustc::ty::subst::{
120 GenericArgKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts,
122 use rustc::ty::util::{Representability, IntTypeExt, Discr};
123 use rustc::ty::layout::VariantIdx;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
125 use syntax_pos::hygiene::DesugaringKind;
128 use syntax::feature_gate::{GateIssue, emit_feature_err};
129 use syntax::source_map::{DUMMY_SP, original_sp};
130 use syntax::symbol::{kw, sym};
132 use std::cell::{Cell, RefCell, Ref, RefMut};
133 use std::collections::hash_map::Entry;
136 use std::mem::replace;
137 use std::ops::{self, Deref};
140 use crate::require_c_abi_if_c_variadic;
141 use crate::session::Session;
142 use crate::session::config::EntryFnType;
143 use crate::TypeAndSubsts;
145 use crate::util::captures::Captures;
146 use crate::util::common::{ErrorReported, indenter};
147 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
149 pub use self::Expectation::*;
150 use self::autoderef::Autoderef;
151 use self::callee::DeferredCallResolution;
152 use self::coercion::{CoerceMany, DynamicCoerceMany};
153 pub use self::compare_method::{compare_impl_method, compare_const_impl};
154 use self::method::{MethodCallee, SelfSource};
155 use self::TupleArgumentsFlag::*;
157 /// The type of a local binding, including the revealed type for anon types.
158 #[derive(Copy, Clone, Debug)]
159 pub struct LocalTy<'tcx> {
161 revealed_ty: Ty<'tcx>
164 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
165 #[derive(Copy, Clone)]
166 struct MaybeInProgressTables<'a, 'tcx> {
167 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
170 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
171 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow(),
175 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
180 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
181 match self.maybe_tables {
182 Some(tables) => tables.borrow_mut(),
184 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
190 /// Closures defined within the function. For example:
193 /// bar(move|| { ... })
196 /// Here, the function `foo()` and the closure passed to
197 /// `bar()` will each have their own `FnCtxt`, but they will
198 /// share the inherited fields.
199 pub struct Inherited<'a, 'tcx> {
200 infcx: InferCtxt<'a, 'tcx>,
202 tables: MaybeInProgressTables<'a, 'tcx>,
204 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
206 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
208 // Some additional `Sized` obligations badly affect type inference.
209 // These obligations are added in a later stage of typeck.
210 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
212 // When we process a call like `c()` where `c` is a closure type,
213 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
214 // `FnOnce` closure. In that case, we defer full resolution of the
215 // call until upvar inference can kick in and make the
216 // decision. We keep these deferred resolutions grouped by the
217 // def-id of the closure, so that once we decide, we can easily go
218 // back and process them.
219 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
221 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
223 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
225 // Opaque types found in explicit return types and their
226 // associated fresh inference variable. Writeback resolves these
227 // variables to get the concrete type, which can be used to
228 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
229 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
231 /// Each type parameter has an implicit region bound that
232 /// indicates it must outlive at least the function body (the user
233 /// may specify stronger requirements). This field indicates the
234 /// region of the callee. If it is `None`, then the parameter
235 /// environment is for an item or something where the "callee" is
237 implicit_region_bound: Option<ty::Region<'tcx>>,
239 body_id: Option<hir::BodyId>,
242 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
243 type Target = InferCtxt<'a, 'tcx>;
244 fn deref(&self) -> &Self::Target {
249 /// When type-checking an expression, we propagate downward
250 /// whatever type hint we are able in the form of an `Expectation`.
251 #[derive(Copy, Clone, Debug)]
252 pub enum Expectation<'tcx> {
253 /// We know nothing about what type this expression should have.
256 /// This expression should have the type given (or some subtype).
257 ExpectHasType(Ty<'tcx>),
259 /// This expression will be cast to the `Ty`.
260 ExpectCastableToType(Ty<'tcx>),
262 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
263 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
264 ExpectRvalueLikeUnsized(Ty<'tcx>),
267 impl<'a, 'tcx> Expectation<'tcx> {
268 // Disregard "castable to" expectations because they
269 // can lead us astray. Consider for example `if cond
270 // {22} else {c} as u8` -- if we propagate the
271 // "castable to u8" constraint to 22, it will pick the
272 // type 22u8, which is overly constrained (c might not
273 // be a u8). In effect, the problem is that the
274 // "castable to" expectation is not the tightest thing
275 // we can say, so we want to drop it in this case.
276 // The tightest thing we can say is "must unify with
277 // else branch". Note that in the case of a "has type"
278 // constraint, this limitation does not hold.
280 // If the expected type is just a type variable, then don't use
281 // an expected type. Otherwise, we might write parts of the type
282 // when checking the 'then' block which are incompatible with the
284 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
286 ExpectHasType(ety) => {
287 let ety = fcx.shallow_resolve(ety);
288 if !ety.is_ty_var() {
294 ExpectRvalueLikeUnsized(ety) => {
295 ExpectRvalueLikeUnsized(ety)
301 /// Provides an expectation for an rvalue expression given an *optional*
302 /// hint, which is not required for type safety (the resulting type might
303 /// be checked higher up, as is the case with `&expr` and `box expr`), but
304 /// is useful in determining the concrete type.
306 /// The primary use case is where the expected type is a fat pointer,
307 /// like `&[isize]`. For example, consider the following statement:
309 /// let x: &[isize] = &[1, 2, 3];
311 /// In this case, the expected type for the `&[1, 2, 3]` expression is
312 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
313 /// expectation `ExpectHasType([isize])`, that would be too strong --
314 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
315 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
316 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
317 /// which still is useful, because it informs integer literals and the like.
318 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
319 /// for examples of where this comes up,.
320 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
321 match fcx.tcx.struct_tail_without_normalization(ty).kind {
322 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
323 ExpectRvalueLikeUnsized(ty)
325 _ => ExpectHasType(ty)
329 // Resolves `expected` by a single level if it is a variable. If
330 // there is no expected type or resolution is not possible (e.g.,
331 // no constraints yet present), just returns `None`.
332 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
334 NoExpectation => NoExpectation,
335 ExpectCastableToType(t) => {
336 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
338 ExpectHasType(t) => {
339 ExpectHasType(fcx.resolve_vars_if_possible(&t))
341 ExpectRvalueLikeUnsized(t) => {
342 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
347 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
348 match self.resolve(fcx) {
349 NoExpectation => None,
350 ExpectCastableToType(ty) |
352 ExpectRvalueLikeUnsized(ty) => Some(ty),
356 /// It sometimes happens that we want to turn an expectation into
357 /// a **hard constraint** (i.e., something that must be satisfied
358 /// for the program to type-check). `only_has_type` will return
359 /// such a constraint, if it exists.
360 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
361 match self.resolve(fcx) {
362 ExpectHasType(ty) => Some(ty),
363 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
367 /// Like `only_has_type`, but instead of returning `None` if no
368 /// hard constraint exists, creates a fresh type variable.
369 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
370 self.only_has_type(fcx)
372 fcx.next_ty_var(TypeVariableOrigin {
373 kind: TypeVariableOriginKind::MiscVariable,
380 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
387 fn maybe_mut_place(m: hir::Mutability) -> Self {
389 hir::MutMutable => Needs::MutPlace,
390 hir::MutImmutable => Needs::None,
395 #[derive(Copy, Clone)]
396 pub struct UnsafetyState {
398 pub unsafety: hir::Unsafety,
399 pub unsafe_push_count: u32,
404 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
405 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
408 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
409 match self.unsafety {
410 // If this unsafe, then if the outer function was already marked as
411 // unsafe we shouldn't attribute the unsafe'ness to the block. This
412 // way the block can be warned about instead of ignoring this
413 // extraneous block (functions are never warned about).
414 hir::Unsafety::Unsafe if self.from_fn => *self,
417 let (unsafety, def, count) = match blk.rules {
418 hir::PushUnsafeBlock(..) =>
419 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
420 hir::PopUnsafeBlock(..) =>
421 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
422 hir::UnsafeBlock(..) =>
423 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
425 (unsafety, self.def, self.unsafe_push_count),
429 unsafe_push_count: count,
436 #[derive(Debug, Copy, Clone)]
442 /// Tracks whether executing a node may exit normally (versus
443 /// return/break/panic, which "diverge", leaving dead code in their
444 /// wake). Tracked semi-automatically (through type variables marked
445 /// as diverging), with some manual adjustments for control-flow
446 /// primitives (approximating a CFG).
447 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
449 /// Potentially unknown, some cases converge,
450 /// others require a CFG to determine them.
453 /// Definitely known to diverge and therefore
454 /// not reach the next sibling or its parent.
456 /// The `Span` points to the expression
457 /// that caused us to diverge
458 /// (e.g. `return`, `break`, etc).
460 /// In some cases (e.g. a `match` expression
461 /// where all arms diverge), we may be
462 /// able to provide a more informative
463 /// message to the user.
464 /// If this is `None`, a default messsage
465 /// will be generated, which is suitable
467 custom_note: Option<&'static str>
470 /// Same as `Always` but with a reachability
471 /// warning already emitted.
475 // Convenience impls for combinig `Diverges`.
477 impl ops::BitAnd for Diverges {
479 fn bitand(self, other: Self) -> Self {
480 cmp::min(self, other)
484 impl ops::BitOr for Diverges {
486 fn bitor(self, other: Self) -> Self {
487 cmp::max(self, other)
491 impl ops::BitAndAssign for Diverges {
492 fn bitand_assign(&mut self, other: Self) {
493 *self = *self & other;
497 impl ops::BitOrAssign for Diverges {
498 fn bitor_assign(&mut self, other: Self) {
499 *self = *self | other;
504 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
505 fn always(span: Span) -> Diverges {
512 fn is_always(self) -> bool {
513 // Enum comparison ignores the
514 // contents of fields, so we just
515 // fill them in with garbage here.
516 self >= Diverges::Always {
523 pub struct BreakableCtxt<'tcx> {
526 // this is `null` for loops where break with a value is illegal,
527 // such as `while`, `for`, and `while let`
528 coerce: Option<DynamicCoerceMany<'tcx>>,
531 pub struct EnclosingBreakables<'tcx> {
532 stack: Vec<BreakableCtxt<'tcx>>,
533 by_id: HirIdMap<usize>,
536 impl<'tcx> EnclosingBreakables<'tcx> {
537 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
538 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
539 bug!("could not find enclosing breakable with id {}", target_id);
545 pub struct FnCtxt<'a, 'tcx> {
548 /// The parameter environment used for proving trait obligations
549 /// in this function. This can change when we descend into
550 /// closures (as they bring new things into scope), hence it is
551 /// not part of `Inherited` (as of the time of this writing,
552 /// closures do not yet change the environment, but they will
554 param_env: ty::ParamEnv<'tcx>,
556 /// Number of errors that had been reported when we started
557 /// checking this function. On exit, if we find that *more* errors
558 /// have been reported, we will skip regionck and other work that
559 /// expects the types within the function to be consistent.
560 // FIXME(matthewjasper) This should not exist, and it's not correct
561 // if type checking is run in parallel.
562 err_count_on_creation: usize,
564 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
565 ret_coercion_span: RefCell<Option<Span>>,
567 yield_ty: Option<Ty<'tcx>>,
569 ps: RefCell<UnsafetyState>,
571 /// Whether the last checked node generates a divergence (e.g.,
572 /// `return` will set this to `Always`). In general, when entering
573 /// an expression or other node in the tree, the initial value
574 /// indicates whether prior parts of the containing expression may
575 /// have diverged. It is then typically set to `Maybe` (and the
576 /// old value remembered) for processing the subparts of the
577 /// current expression. As each subpart is processed, they may set
578 /// the flag to `Always`, etc. Finally, at the end, we take the
579 /// result and "union" it with the original value, so that when we
580 /// return the flag indicates if any subpart of the parent
581 /// expression (up to and including this part) has diverged. So,
582 /// if you read it after evaluating a subexpression `X`, the value
583 /// you get indicates whether any subexpression that was
584 /// evaluating up to and including `X` diverged.
586 /// We currently use this flag only for diagnostic purposes:
588 /// - To warn about unreachable code: if, after processing a
589 /// sub-expression but before we have applied the effects of the
590 /// current node, we see that the flag is set to `Always`, we
591 /// can issue a warning. This corresponds to something like
592 /// `foo(return)`; we warn on the `foo()` expression. (We then
593 /// update the flag to `WarnedAlways` to suppress duplicate
594 /// reports.) Similarly, if we traverse to a fresh statement (or
595 /// tail expression) from a `Always` setting, we will issue a
596 /// warning. This corresponds to something like `{return;
597 /// foo();}` or `{return; 22}`, where we would warn on the
600 /// An expression represents dead code if, after checking it,
601 /// the diverges flag is set to something other than `Maybe`.
602 diverges: Cell<Diverges>,
604 /// Whether any child nodes have any type errors.
605 has_errors: Cell<bool>,
607 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
609 inh: &'a Inherited<'a, 'tcx>,
612 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
613 type Target = Inherited<'a, 'tcx>;
614 fn deref(&self) -> &Self::Target {
619 /// Helper type of a temporary returned by `Inherited::build(...)`.
620 /// Necessary because we can't write the following bound:
621 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
622 pub struct InheritedBuilder<'tcx> {
623 infcx: infer::InferCtxtBuilder<'tcx>,
627 impl Inherited<'_, 'tcx> {
628 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
629 let hir_id_root = if def_id.is_local() {
630 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
631 DefId::local(hir_id.owner)
637 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
643 impl<'tcx> InheritedBuilder<'tcx> {
644 fn enter<F, R>(&mut self, f: F) -> R
646 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
648 let def_id = self.def_id;
649 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
653 impl Inherited<'a, 'tcx> {
654 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
656 let item_id = tcx.hir().as_local_hir_id(def_id);
657 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
658 let implicit_region_bound = body_id.map(|body_id| {
659 let body = tcx.hir().body(body_id);
660 tcx.mk_region(ty::ReScope(region::Scope {
661 id: body.value.hir_id.local_id,
662 data: region::ScopeData::CallSite
667 tables: MaybeInProgressTables {
668 maybe_tables: infcx.in_progress_tables,
671 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
672 locals: RefCell::new(Default::default()),
673 deferred_sized_obligations: RefCell::new(Vec::new()),
674 deferred_call_resolutions: RefCell::new(Default::default()),
675 deferred_cast_checks: RefCell::new(Vec::new()),
676 deferred_generator_interiors: RefCell::new(Vec::new()),
677 opaque_types: RefCell::new(Default::default()),
678 implicit_region_bound,
683 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
684 debug!("register_predicate({:?})", obligation);
685 if obligation.has_escaping_bound_vars() {
686 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
691 .register_predicate_obligation(self, obligation);
694 fn register_predicates<I>(&self, obligations: I)
695 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
697 for obligation in obligations {
698 self.register_predicate(obligation);
702 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
703 self.register_predicates(infer_ok.obligations);
707 fn normalize_associated_types_in<T>(&self,
710 param_env: ty::ParamEnv<'tcx>,
712 where T : TypeFoldable<'tcx>
714 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
715 self.register_infer_ok_obligations(ok)
719 struct CheckItemTypesVisitor<'tcx> {
723 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
724 fn visit_item(&mut self, i: &'tcx hir::Item) {
725 check_item_type(self.tcx, i);
727 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
728 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
731 pub fn check_wf_new(tcx: TyCtxt<'_>) {
732 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
733 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
736 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
737 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
740 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
741 debug_assert!(crate_num == LOCAL_CRATE);
742 tcx.par_body_owners(|body_owner_def_id| {
743 tcx.ensure().typeck_tables_of(body_owner_def_id);
747 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
748 wfcheck::check_item_well_formed(tcx, def_id);
751 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
752 wfcheck::check_trait_item(tcx, def_id);
755 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
756 wfcheck::check_impl_item(tcx, def_id);
759 pub fn provide(providers: &mut Providers<'_>) {
760 method::provide(providers);
761 *providers = Providers {
767 check_item_well_formed,
768 check_trait_item_well_formed,
769 check_impl_item_well_formed,
770 check_mod_item_types,
775 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
776 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
779 /// If this `DefId` is a "primary tables entry", returns
780 /// `Some((body_id, header, decl))` with information about
781 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
784 /// If this function returns `Some`, then `typeck_tables(def_id)` will
785 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
786 /// may not succeed. In some cases where this function returns `None`
787 /// (notably closures), `typeck_tables(def_id)` would wind up
788 /// redirecting to the owning function.
792 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
793 match tcx.hir().get(id) {
794 Node::Item(item) => {
796 hir::ItemKind::Const(ref ty, body) |
797 hir::ItemKind::Static(ref ty, _, body) =>
798 Some((body, Some(ty), None, None)),
799 hir::ItemKind::Fn(ref decl, ref header, .., body) =>
800 Some((body, None, Some(header), Some(decl))),
805 Node::TraitItem(item) => {
807 hir::TraitItemKind::Const(ref ty, Some(body)) =>
808 Some((body, Some(ty), None, None)),
809 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
810 Some((body, None, Some(&sig.header), Some(&sig.decl))),
815 Node::ImplItem(item) => {
817 hir::ImplItemKind::Const(ref ty, body) =>
818 Some((body, Some(ty), None, None)),
819 hir::ImplItemKind::Method(ref sig, body) =>
820 Some((body, None, Some(&sig.header), Some(&sig.decl))),
825 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
830 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
831 // Closures' tables come from their outermost function,
832 // as they are part of the same "inference environment".
833 let outer_def_id = tcx.closure_base_def_id(def_id);
834 if outer_def_id != def_id {
835 return tcx.has_typeck_tables(outer_def_id);
838 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
839 primary_body_of(tcx, id).is_some()
842 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
843 &*tcx.typeck_tables_of(def_id).used_trait_imports
846 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
847 // Closures' tables come from their outermost function,
848 // as they are part of the same "inference environment".
849 let outer_def_id = tcx.closure_base_def_id(def_id);
850 if outer_def_id != def_id {
851 return tcx.typeck_tables_of(outer_def_id);
854 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
855 let span = tcx.hir().span(id);
857 // Figure out what primary body this item has.
858 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
860 span_bug!(span, "can't type-check body of {:?}", def_id);
862 let body = tcx.hir().body(body_id);
864 let tables = Inherited::build(tcx, def_id).enter(|inh| {
865 let param_env = tcx.param_env(def_id);
866 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
867 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
868 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
869 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
874 check_abi(tcx, span, fn_sig.abi());
876 // Compute the fty from point of view of inside the fn.
878 tcx.liberate_late_bound_regions(def_id, &fn_sig);
880 inh.normalize_associated_types_in(body.value.span,
885 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
888 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
889 let expected_type = body_ty.and_then(|ty| match ty.kind {
890 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
892 }).unwrap_or_else(|| tcx.type_of(def_id));
893 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
894 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
896 let revealed_ty = if tcx.features().impl_trait_in_bindings {
897 fcx.instantiate_opaque_types_from_value(
906 // Gather locals in statics (because of block expressions).
907 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
909 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
911 fcx.write_ty(id, revealed_ty);
916 // All type checking constraints were added, try to fallback unsolved variables.
917 fcx.select_obligations_where_possible(false, |_| {});
918 let mut fallback_has_occurred = false;
919 for ty in &fcx.unsolved_variables() {
920 fallback_has_occurred |= fcx.fallback_if_possible(ty);
922 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
924 // Even though coercion casts provide type hints, we check casts after fallback for
925 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
928 // Closure and generator analysis may run after fallback
929 // because they don't constrain other type variables.
930 fcx.closure_analyze(body);
931 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
932 fcx.resolve_generator_interiors(def_id);
934 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
935 let ty = fcx.normalize_ty(span, ty);
936 fcx.require_type_is_sized(ty, span, code);
938 fcx.select_all_obligations_or_error();
940 if fn_decl.is_some() {
941 fcx.regionck_fn(id, body);
943 fcx.regionck_expr(body);
946 fcx.resolve_type_vars_in_body(body)
949 // Consistency check our TypeckTables instance can hold all ItemLocalIds
950 // it will need to hold.
951 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
956 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
957 if !tcx.sess.target.target.is_abi_supported(abi) {
958 struct_span_err!(tcx.sess, span, E0570,
959 "The ABI `{}` is not supported for the current target", abi).emit()
963 struct GatherLocalsVisitor<'a, 'tcx> {
964 fcx: &'a FnCtxt<'a, 'tcx>,
965 parent_id: hir::HirId,
968 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
969 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
972 // infer the variable's type
973 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
974 kind: TypeVariableOriginKind::TypeInference,
977 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
984 // take type that the user specified
985 self.fcx.locals.borrow_mut().insert(nid, typ);
992 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
993 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
994 NestedVisitorMap::None
997 // Add explicitly-declared locals.
998 fn visit_local(&mut self, local: &'tcx hir::Local) {
999 let local_ty = match local.ty {
1001 let o_ty = self.fcx.to_ty(&ty);
1003 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1004 self.fcx.instantiate_opaque_types_from_value(
1013 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
1014 &UserType::Ty(revealed_ty)
1016 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1017 ty.hir_id, o_ty, revealed_ty, c_ty);
1018 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1020 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1024 self.assign(local.span, local.hir_id, local_ty);
1026 debug!("local variable {:?} is assigned type {}",
1028 self.fcx.ty_to_string(
1029 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1030 intravisit::walk_local(self, local);
1033 // Add pattern bindings.
1034 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1035 if let PatKind::Binding(_, _, ident, _) = p.kind {
1036 let var_ty = self.assign(p.span, p.hir_id, None);
1038 if !self.fcx.tcx.features().unsized_locals {
1039 self.fcx.require_type_is_sized(var_ty, p.span,
1040 traits::VariableType(p.hir_id));
1043 debug!("pattern binding {} is assigned to {} with type {:?}",
1045 self.fcx.ty_to_string(
1046 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1049 intravisit::walk_pat(self, p);
1052 // Don't descend into the bodies of nested closures
1055 _: intravisit::FnKind<'tcx>,
1056 _: &'tcx hir::FnDecl,
1063 /// When `check_fn` is invoked on a generator (i.e., a body that
1064 /// includes yield), it returns back some information about the yield
1066 struct GeneratorTypes<'tcx> {
1067 /// Type of value that is yielded.
1070 /// Types that are captured (see `GeneratorInterior` for more).
1073 /// Indicates if the generator is movable or static (immovable).
1074 movability: hir::GeneratorMovability,
1077 /// Helper used for fns and closures. Does the grungy work of checking a function
1078 /// body and returns the function context used for that purpose, since in the case of a fn item
1079 /// there is still a bit more to do.
1082 /// * inherited: other fields inherited from the enclosing fn (if any)
1083 fn check_fn<'a, 'tcx>(
1084 inherited: &'a Inherited<'a, 'tcx>,
1085 param_env: ty::ParamEnv<'tcx>,
1086 fn_sig: ty::FnSig<'tcx>,
1087 decl: &'tcx hir::FnDecl,
1089 body: &'tcx hir::Body,
1090 can_be_generator: Option<hir::GeneratorMovability>,
1091 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1092 let mut fn_sig = fn_sig.clone();
1094 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1096 // Create the function context. This is either derived from scratch or,
1097 // in the case of closures, based on the outer context.
1098 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1099 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1101 let declared_ret_ty = fn_sig.output();
1102 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1103 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1108 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1109 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1110 fn_sig = fcx.tcx.mk_fn_sig(
1111 fn_sig.inputs().iter().cloned(),
1118 let span = body.value.span;
1120 fn_maybe_err(fcx.tcx, span, fn_sig.abi);
1122 if body.generator_kind.is_some() && can_be_generator.is_some() {
1123 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1124 kind: TypeVariableOriginKind::TypeInference,
1127 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1128 fcx.yield_ty = Some(yield_ty);
1131 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1132 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1133 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1135 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1136 // (as it's created inside the body itself, not passed in from outside).
1137 let maybe_va_list = if fn_sig.c_variadic {
1138 let va_list_did = fcx.tcx.require_lang_item(
1139 lang_items::VaListTypeLangItem,
1140 Some(body.params.last().unwrap().span),
1142 let region = fcx.tcx.mk_region(ty::ReScope(region::Scope {
1143 id: body.value.hir_id.local_id,
1144 data: region::ScopeData::CallSite
1147 Some(fcx.tcx.type_of(va_list_did).subst(fcx.tcx, &[region.into()]))
1152 // Add formal parameters.
1153 for (param_ty, param) in
1154 fn_sig.inputs().iter().copied()
1155 .chain(maybe_va_list)
1158 // Check the pattern.
1159 fcx.check_pat_top(¶m.pat, param_ty, None);
1161 // Check that argument is Sized.
1162 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1163 // for simple cases like `fn foo(x: Trait)`,
1164 // where we would error once on the parameter as a whole, and once on the binding `x`.
1165 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1166 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1169 fcx.write_ty(param.hir_id, param_ty);
1172 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1174 fcx.check_return_expr(&body.value);
1176 // We insert the deferred_generator_interiors entry after visiting the body.
1177 // This ensures that all nested generators appear before the entry of this generator.
1178 // resolve_generator_interiors relies on this property.
1179 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1180 let interior = fcx.next_ty_var(TypeVariableOrigin {
1181 kind: TypeVariableOriginKind::MiscVariable,
1184 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1185 Some(GeneratorTypes {
1186 yield_ty: fcx.yield_ty.unwrap(),
1188 movability: can_be_generator.unwrap(),
1194 // Finalize the return check by taking the LUB of the return types
1195 // we saw and assigning it to the expected return type. This isn't
1196 // really expected to fail, since the coercions would have failed
1197 // earlier when trying to find a LUB.
1199 // However, the behavior around `!` is sort of complex. In the
1200 // event that the `actual_return_ty` comes back as `!`, that
1201 // indicates that the fn either does not return or "returns" only
1202 // values of type `!`. In this case, if there is an expected
1203 // return type that is *not* `!`, that should be ok. But if the
1204 // return type is being inferred, we want to "fallback" to `!`:
1206 // let x = move || panic!();
1208 // To allow for that, I am creating a type variable with diverging
1209 // fallback. This was deemed ever so slightly better than unifying
1210 // the return value with `!` because it allows for the caller to
1211 // make more assumptions about the return type (e.g., they could do
1213 // let y: Option<u32> = Some(x());
1215 // which would then cause this return type to become `u32`, not
1217 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1218 let mut actual_return_ty = coercion.complete(&fcx);
1219 if actual_return_ty.is_never() {
1220 actual_return_ty = fcx.next_diverging_ty_var(
1221 TypeVariableOrigin {
1222 kind: TypeVariableOriginKind::DivergingFn,
1227 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1229 // Check that the main return type implements the termination trait.
1230 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1231 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1232 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1233 if main_id == fn_id {
1234 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1235 let trait_ref = ty::TraitRef::new(term_id, substs);
1236 let return_ty_span = decl.output.span();
1237 let cause = traits::ObligationCause::new(
1238 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1240 inherited.register_predicate(
1241 traits::Obligation::new(
1242 cause, param_env, trait_ref.to_predicate()));
1247 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1248 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1249 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1250 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1251 // at this point we don't care if there are duplicate handlers or if the handler has
1252 // the wrong signature as this value we'll be used when writing metadata and that
1253 // only happens if compilation succeeded
1254 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1256 if declared_ret_ty.kind != ty::Never {
1257 fcx.tcx.sess.span_err(
1259 "return type should be `!`",
1263 let inputs = fn_sig.inputs();
1264 let span = fcx.tcx.hir().span(fn_id);
1265 if inputs.len() == 1 {
1266 let arg_is_panic_info = match inputs[0].kind {
1267 ty::Ref(region, ty, mutbl) => match ty.kind {
1268 ty::Adt(ref adt, _) => {
1269 adt.did == panic_info_did &&
1270 mutbl == hir::Mutability::MutImmutable &&
1271 *region != RegionKind::ReStatic
1278 if !arg_is_panic_info {
1279 fcx.tcx.sess.span_err(
1280 decl.inputs[0].span,
1281 "argument should be `&PanicInfo`",
1285 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1286 if let ItemKind::Fn(_, _, ref generics, _) = item.kind {
1287 if !generics.params.is_empty() {
1288 fcx.tcx.sess.span_err(
1290 "should have no type parameters",
1296 let span = fcx.tcx.sess.source_map().def_span(span);
1297 fcx.tcx.sess.span_err(span, "function should have one argument");
1300 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1305 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1306 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1307 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1308 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1309 if declared_ret_ty.kind != ty::Never {
1310 fcx.tcx.sess.span_err(
1312 "return type should be `!`",
1316 let inputs = fn_sig.inputs();
1317 let span = fcx.tcx.hir().span(fn_id);
1318 if inputs.len() == 1 {
1319 let arg_is_alloc_layout = match inputs[0].kind {
1320 ty::Adt(ref adt, _) => {
1321 adt.did == alloc_layout_did
1326 if !arg_is_alloc_layout {
1327 fcx.tcx.sess.span_err(
1328 decl.inputs[0].span,
1329 "argument should be `Layout`",
1333 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1334 if let ItemKind::Fn(_, _, ref generics, _) = item.kind {
1335 if !generics.params.is_empty() {
1336 fcx.tcx.sess.span_err(
1338 "`#[alloc_error_handler]` function should have no type \
1345 let span = fcx.tcx.sess.source_map().def_span(span);
1346 fcx.tcx.sess.span_err(span, "function should have one argument");
1349 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1357 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1358 let def_id = tcx.hir().local_def_id(id);
1359 let def = tcx.adt_def(def_id);
1360 def.destructor(tcx); // force the destructor to be evaluated
1361 check_representable(tcx, span, def_id);
1363 if def.repr.simd() {
1364 check_simd(tcx, span, def_id);
1367 check_transparent(tcx, span, def_id);
1368 check_packed(tcx, span, def_id);
1371 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1372 let def_id = tcx.hir().local_def_id(id);
1373 let def = tcx.adt_def(def_id);
1374 def.destructor(tcx); // force the destructor to be evaluated
1375 check_representable(tcx, span, def_id);
1376 check_transparent(tcx, span, def_id);
1377 check_packed(tcx, span, def_id);
1380 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1381 /// projections that would result in "inheriting lifetimes".
1382 fn check_opaque<'tcx>(
1385 substs: SubstsRef<'tcx>,
1387 origin: &hir::OpaqueTyOrigin,
1389 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1390 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1393 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1394 /// in "inheriting lifetimes".
1395 fn check_opaque_for_inheriting_lifetimes(
1400 let item = tcx.hir().expect_item(
1401 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1402 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1403 def_id, span, item);
1406 struct ProhibitOpaqueVisitor<'tcx> {
1407 opaque_identity_ty: Ty<'tcx>,
1408 generics: &'tcx ty::Generics,
1411 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1412 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1413 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1414 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1417 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1418 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1419 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1420 return *index < self.generics.parent_count as u32;
1423 r.super_visit_with(self)
1427 let prohibit_opaque = match item.kind {
1428 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1429 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1430 let mut visitor = ProhibitOpaqueVisitor {
1431 opaque_identity_ty: tcx.mk_opaque(
1432 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1433 generics: tcx.generics_of(def_id),
1435 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1437 tcx.predicates_of(def_id).predicates.iter().any(
1438 |(predicate, _)| predicate.visit_with(&mut visitor))
1443 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1444 if prohibit_opaque {
1445 let is_async = match item.kind {
1446 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1447 hir::OpaqueTyOrigin::AsyncFn => true,
1450 _ => unreachable!(),
1453 tcx.sess.span_err(span, &format!(
1454 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1456 if is_async { "async fn" } else { "impl Trait" },
1461 /// Checks that an opaque type does not contain cycles.
1462 fn check_opaque_for_cycles<'tcx>(
1465 substs: SubstsRef<'tcx>,
1467 origin: &hir::OpaqueTyOrigin,
1469 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1470 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1472 tcx.sess, span, E0733,
1473 "recursion in an `async fn` requires boxing",
1475 .span_label(span, "recursive `async fn`")
1476 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1479 let mut err = struct_span_err!(
1480 tcx.sess, span, E0720,
1481 "opaque type expands to a recursive type",
1483 err.span_label(span, "expands to a recursive type");
1484 if let ty::Opaque(..) = partially_expanded_type.kind {
1485 err.note("type resolves to itself");
1487 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1494 // Forbid defining intrinsics in Rust code,
1495 // as they must always be defined by the compiler.
1496 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1497 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1498 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1502 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1504 "check_item_type(it.hir_id={}, it.name={})",
1506 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1508 let _indenter = indenter();
1510 // Consts can play a role in type-checking, so they are included here.
1511 hir::ItemKind::Static(..) => {
1512 let def_id = tcx.hir().local_def_id(it.hir_id);
1513 tcx.typeck_tables_of(def_id);
1514 maybe_check_static_with_link_section(tcx, def_id, it.span);
1516 hir::ItemKind::Const(..) => {
1517 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1519 hir::ItemKind::Enum(ref enum_definition, _) => {
1520 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1522 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1523 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1524 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1525 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1526 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1527 check_impl_items_against_trait(
1534 let trait_def_id = impl_trait_ref.def_id;
1535 check_on_unimplemented(tcx, trait_def_id, it);
1538 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1539 let def_id = tcx.hir().local_def_id(it.hir_id);
1540 check_on_unimplemented(tcx, def_id, it);
1542 for item in items.iter() {
1543 let item = tcx.hir().trait_item(item.id);
1544 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1545 let abi = sig.header.abi;
1546 fn_maybe_err(tcx, item.ident.span, abi);
1550 hir::ItemKind::Struct(..) => {
1551 check_struct(tcx, it.hir_id, it.span);
1553 hir::ItemKind::Union(..) => {
1554 check_union(tcx, it.hir_id, it.span);
1556 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1557 let def_id = tcx.hir().local_def_id(it.hir_id);
1559 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1560 check_opaque(tcx, def_id, substs, it.span, &origin);
1562 hir::ItemKind::TyAlias(..) => {
1563 let def_id = tcx.hir().local_def_id(it.hir_id);
1564 let pty_ty = tcx.type_of(def_id);
1565 let generics = tcx.generics_of(def_id);
1566 check_bounds_are_used(tcx, &generics, pty_ty);
1568 hir::ItemKind::ForeignMod(ref m) => {
1569 check_abi(tcx, it.span, m.abi);
1571 if m.abi == Abi::RustIntrinsic {
1572 for item in &m.items {
1573 intrinsic::check_intrinsic_type(tcx, item);
1575 } else if m.abi == Abi::PlatformIntrinsic {
1576 for item in &m.items {
1577 intrinsic::check_platform_intrinsic_type(tcx, item);
1580 for item in &m.items {
1581 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1582 let own_counts = generics.own_counts();
1583 if generics.params.len() - own_counts.lifetimes != 0 {
1584 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1585 (_, 0) => ("type", "types", Some("u32")),
1586 // We don't specify an example value, because we can't generate
1587 // a valid value for any type.
1588 (0, _) => ("const", "consts", None),
1589 _ => ("type or const", "types or consts", None),
1595 "foreign items may not have {} parameters",
1599 &format!("can't have {} parameters", kinds),
1601 // FIXME: once we start storing spans for type arguments, turn this
1602 // into a suggestion.
1604 "replace the {} parameters with concrete {}{}",
1607 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1612 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1613 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1618 _ => { /* nothing to do */ }
1622 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1623 // Only restricted on wasm32 target for now
1624 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1628 // If `#[link_section]` is missing, then nothing to verify
1629 let attrs = tcx.codegen_fn_attrs(id);
1630 if attrs.link_section.is_none() {
1634 // For the wasm32 target statics with `#[link_section]` are placed into custom
1635 // sections of the final output file, but this isn't link custom sections of
1636 // other executable formats. Namely we can only embed a list of bytes,
1637 // nothing with pointers to anything else or relocations. If any relocation
1638 // show up, reject them here.
1639 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1640 // the consumer's responsibility to ensure all bytes that have been read
1641 // have defined values.
1642 let instance = ty::Instance::mono(tcx, id);
1643 let cid = GlobalId {
1647 let param_env = ty::ParamEnv::reveal_all();
1648 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1649 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1652 bug!("Matching on non-ByRef static")
1654 if alloc.relocations().len() != 0 {
1655 let msg = "statics with a custom `#[link_section]` must be a \
1656 simple list of bytes on the wasm target with no \
1657 extra levels of indirection such as references";
1658 tcx.sess.span_err(span, msg);
1663 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1664 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1665 // an error would be reported if this fails.
1666 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1669 fn report_forbidden_specialization(
1671 impl_item: &hir::ImplItem,
1674 let mut err = struct_span_err!(
1675 tcx.sess, impl_item.span, E0520,
1676 "`{}` specializes an item from a parent `impl`, but \
1677 that item is not marked `default`",
1679 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1682 match tcx.span_of_impl(parent_impl) {
1684 err.span_label(span, "parent `impl` is here");
1685 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1689 err.note(&format!("parent implementation is in crate `{}`", cname));
1696 fn check_specialization_validity<'tcx>(
1698 trait_def: &ty::TraitDef,
1699 trait_item: &ty::AssocItem,
1701 impl_item: &hir::ImplItem,
1703 let ancestors = trait_def.ancestors(tcx, impl_id);
1705 let kind = match impl_item.kind {
1706 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1707 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1708 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1709 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1712 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1713 .map(|node_item| node_item.map(|parent| parent.defaultness));
1715 if let Some(parent) = parent {
1716 if tcx.impl_item_is_final(&parent) {
1717 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1723 fn check_impl_items_against_trait<'tcx>(
1727 impl_trait_ref: ty::TraitRef<'tcx>,
1728 impl_item_refs: &[hir::ImplItemRef],
1730 let impl_span = tcx.sess.source_map().def_span(impl_span);
1732 // If the trait reference itself is erroneous (so the compilation is going
1733 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1734 // isn't populated for such impls.
1735 if impl_trait_ref.references_error() { return; }
1737 // Locate trait definition and items
1738 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1739 let mut overridden_associated_type = None;
1741 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1743 // Check existing impl methods to see if they are both present in trait
1744 // and compatible with trait signature
1745 for impl_item in impl_items() {
1746 let ty_impl_item = tcx.associated_item(
1747 tcx.hir().local_def_id(impl_item.hir_id));
1748 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1749 .find(|ac| Namespace::from(&impl_item.kind) == Namespace::from(ac.kind) &&
1750 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1752 // Not compatible, but needed for the error message
1753 tcx.associated_items(impl_trait_ref.def_id)
1754 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1757 // Check that impl definition matches trait definition
1758 if let Some(ty_trait_item) = ty_trait_item {
1759 match impl_item.kind {
1760 hir::ImplItemKind::Const(..) => {
1761 // Find associated const definition.
1762 if ty_trait_item.kind == ty::AssocKind::Const {
1763 compare_const_impl(tcx,
1769 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1770 "item `{}` is an associated const, \
1771 which doesn't match its trait `{}`",
1774 err.span_label(impl_item.span, "does not match trait");
1775 // We can only get the spans from local trait definition
1776 // Same for E0324 and E0325
1777 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1778 err.span_label(trait_span, "item in trait");
1783 hir::ImplItemKind::Method(..) => {
1784 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1785 if ty_trait_item.kind == ty::AssocKind::Method {
1786 compare_impl_method(tcx,
1793 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1794 "item `{}` is an associated method, \
1795 which doesn't match its trait `{}`",
1798 err.span_label(impl_item.span, "does not match trait");
1799 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1800 err.span_label(trait_span, "item in trait");
1805 hir::ImplItemKind::OpaqueTy(..) |
1806 hir::ImplItemKind::TyAlias(_) => {
1807 if ty_trait_item.kind == ty::AssocKind::Type {
1808 if ty_trait_item.defaultness.has_value() {
1809 overridden_associated_type = Some(impl_item);
1812 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1813 "item `{}` is an associated type, \
1814 which doesn't match its trait `{}`",
1817 err.span_label(impl_item.span, "does not match trait");
1818 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1819 err.span_label(trait_span, "item in trait");
1826 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1830 // Check for missing items from trait
1831 let mut missing_items = Vec::new();
1832 let mut invalidated_items = Vec::new();
1833 let associated_type_overridden = overridden_associated_type.is_some();
1834 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1835 let is_implemented = trait_def.ancestors(tcx, impl_id)
1836 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1838 .map(|node_item| !node_item.node.is_from_trait())
1841 if !is_implemented && !tcx.impl_is_default(impl_id) {
1842 if !trait_item.defaultness.has_value() {
1843 missing_items.push(trait_item);
1844 } else if associated_type_overridden {
1845 invalidated_items.push(trait_item.ident);
1850 if !missing_items.is_empty() {
1851 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1852 "not all trait items implemented, missing: `{}`",
1853 missing_items.iter()
1854 .map(|trait_item| trait_item.ident.to_string())
1855 .collect::<Vec<_>>().join("`, `"));
1856 err.span_label(impl_span, format!("missing `{}` in implementation",
1857 missing_items.iter()
1858 .map(|trait_item| trait_item.ident.to_string())
1859 .collect::<Vec<_>>().join("`, `")));
1860 for trait_item in missing_items {
1861 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1862 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1864 err.note_trait_signature(trait_item.ident.to_string(),
1865 trait_item.signature(tcx));
1871 if !invalidated_items.is_empty() {
1872 let invalidator = overridden_associated_type.unwrap();
1873 span_err!(tcx.sess, invalidator.span, E0399,
1874 "the following trait items need to be reimplemented \
1875 as `{}` was overridden: `{}`",
1877 invalidated_items.iter()
1878 .map(|name| name.to_string())
1879 .collect::<Vec<_>>().join("`, `"))
1883 /// Checks whether a type can be represented in memory. In particular, it
1884 /// identifies types that contain themselves without indirection through a
1885 /// pointer, which would mean their size is unbounded.
1886 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1887 let rty = tcx.type_of(item_def_id);
1889 // Check that it is possible to represent this type. This call identifies
1890 // (1) types that contain themselves and (2) types that contain a different
1891 // recursive type. It is only necessary to throw an error on those that
1892 // contain themselves. For case 2, there must be an inner type that will be
1893 // caught by case 1.
1894 match rty.is_representable(tcx, sp) {
1895 Representability::SelfRecursive(spans) => {
1896 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1898 err.span_label(span, "recursive without indirection");
1903 Representability::Representable | Representability::ContainsRecursive => (),
1908 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1909 let t = tcx.type_of(def_id);
1910 if let ty::Adt(def, substs) = t.kind {
1911 if def.is_struct() {
1912 let fields = &def.non_enum_variant().fields;
1913 if fields.is_empty() {
1914 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1917 let e = fields[0].ty(tcx, substs);
1918 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1919 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1920 .span_label(sp, "SIMD elements must have the same type")
1925 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1926 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1928 span_err!(tcx.sess, sp, E0077,
1929 "SIMD vector element type should be machine type");
1937 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1938 let repr = tcx.adt_def(def_id).repr;
1940 for attr in tcx.get_attrs(def_id).iter() {
1941 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1942 if let attr::ReprPacked(pack) = r {
1943 if let Some(repr_pack) = repr.pack {
1944 if pack as u64 != repr_pack.bytes() {
1946 tcx.sess, sp, E0634,
1947 "type has conflicting packed representation hints"
1954 if repr.align.is_some() {
1955 struct_span_err!(tcx.sess, sp, E0587,
1956 "type has conflicting packed and align representation hints").emit();
1958 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1959 struct_span_err!(tcx.sess, sp, E0588,
1960 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1965 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1966 let t = tcx.type_of(def_id);
1967 if stack.contains(&def_id) {
1968 debug!("check_packed_inner: {:?} is recursive", t);
1971 if let ty::Adt(def, substs) = t.kind {
1972 if def.is_struct() || def.is_union() {
1973 if tcx.adt_def(def.did).repr.align.is_some() {
1976 // push struct def_id before checking fields
1978 for field in &def.non_enum_variant().fields {
1979 let f = field.ty(tcx, substs);
1980 if let ty::Adt(def, _) = f.kind {
1981 if check_packed_inner(tcx, def.did, stack) {
1986 // only need to pop if not early out
1993 /// Emit an error when encountering more or less than one variant in a transparent enum.
1994 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1995 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1996 tcx.hir().span_if_local(variant.def_id).unwrap()
1999 "needs exactly one variant, but has {}",
2002 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2003 err.span_label(sp, &msg);
2004 if let &[ref start @ .., ref end] = &variant_spans[..] {
2005 for variant_span in start {
2006 err.span_label(*variant_span, "");
2008 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2013 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2015 fn bad_non_zero_sized_fields<'tcx>(
2017 adt: &'tcx ty::AdtDef,
2019 field_spans: impl Iterator<Item = Span>,
2022 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2023 let mut err = struct_span_err!(
2027 "{}transparent {} {}",
2028 if adt.is_enum() { "the variant of a " } else { "" },
2032 err.span_label(sp, &msg);
2033 for sp in field_spans {
2034 err.span_label(sp, "this field is non-zero-sized");
2039 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2040 let adt = tcx.adt_def(def_id);
2041 if !adt.repr.transparent() {
2044 let sp = tcx.sess.source_map().def_span(sp);
2047 if !tcx.features().transparent_enums {
2049 &tcx.sess.parse_sess,
2050 sym::transparent_enums,
2052 GateIssue::Language,
2053 "transparent enums are unstable",
2056 if adt.variants.len() != 1 {
2057 bad_variant_count(tcx, adt, sp, def_id);
2058 if adt.variants.is_empty() {
2059 // Don't bother checking the fields. No variants (and thus no fields) exist.
2065 if adt.is_union() && !tcx.features().transparent_unions {
2066 emit_feature_err(&tcx.sess.parse_sess,
2067 sym::transparent_unions,
2069 GateIssue::Language,
2070 "transparent unions are unstable");
2073 // For each field, figure out if it's known to be a ZST and align(1)
2074 let field_infos = adt.all_fields().map(|field| {
2075 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2076 let param_env = tcx.param_env(field.did);
2077 let layout = tcx.layout_of(param_env.and(ty));
2078 // We are currently checking the type this field came from, so it must be local
2079 let span = tcx.hir().span_if_local(field.did).unwrap();
2080 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2081 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2085 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2090 let non_zst_count = non_zst_fields.clone().count();
2091 if non_zst_count != 1 {
2092 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2094 for (span, zst, align1) in field_infos {
2100 "zero-sized field in transparent {} has alignment larger than 1",
2102 ).span_label(span, "has alignment larger than 1").emit();
2107 #[allow(trivial_numeric_casts)]
2108 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
2109 let def_id = tcx.hir().local_def_id(id);
2110 let def = tcx.adt_def(def_id);
2111 def.destructor(tcx); // force the destructor to be evaluated
2114 let attributes = tcx.get_attrs(def_id);
2115 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2117 tcx.sess, attr.span, E0084,
2118 "unsupported representation for zero-variant enum")
2119 .span_label(sp, "zero-variant enum")
2124 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2125 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2126 if !tcx.features().repr128 {
2127 emit_feature_err(&tcx.sess.parse_sess,
2130 GateIssue::Language,
2131 "repr with 128-bit type is unstable");
2136 if let Some(ref e) = v.disr_expr {
2137 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2141 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2143 |var: &hir::Variant| match var.data {
2144 hir::VariantData::Unit(..) => true,
2148 let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
2149 let has_non_units = vs.iter().any(|var| !is_unit(var));
2150 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2151 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2153 if disr_non_unit || (disr_units && has_non_units) {
2154 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2155 "`#[repr(inttype)]` must be specified");
2160 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2161 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2162 // Check for duplicate discriminant values
2163 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2164 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2165 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2166 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2167 let i_span = match variant_i.disr_expr {
2168 Some(ref expr) => tcx.hir().span(expr.hir_id),
2169 None => tcx.hir().span(variant_i_hir_id)
2171 let span = match v.disr_expr {
2172 Some(ref expr) => tcx.hir().span(expr.hir_id),
2175 struct_span_err!(tcx.sess, span, E0081,
2176 "discriminant value `{}` already exists", disr_vals[i])
2177 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2178 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2181 disr_vals.push(discr);
2184 check_representable(tcx, sp, def_id);
2185 check_transparent(tcx, sp, def_id);
2188 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2189 span_err!(tcx.sess, span, E0533,
2190 "expected unit struct/variant or constant, found {} `{}`",
2192 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2195 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2196 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2200 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2201 -> &'tcx ty::GenericPredicates<'tcx>
2204 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2205 let item_id = tcx.hir().ty_param_owner(hir_id);
2206 let item_def_id = tcx.hir().local_def_id(item_id);
2207 let generics = tcx.generics_of(item_def_id);
2208 let index = generics.param_def_id_to_index[&def_id];
2209 tcx.arena.alloc(ty::GenericPredicates {
2211 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2213 ty::Predicate::Trait(ref data)
2214 if data.skip_binder().self_ty().is_param(index) => {
2215 // HACK(eddyb) should get the original `Span`.
2216 let span = tcx.def_span(def_id);
2217 Some((predicate, span))
2227 def: Option<&ty::GenericParamDef>,
2229 ) -> Option<ty::Region<'tcx>> {
2231 Some(def) => infer::EarlyBoundRegion(span, def.name),
2232 None => infer::MiscVariable(span)
2234 Some(self.next_region_var(v))
2237 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2238 if let Some(param) = param {
2239 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2244 self.next_ty_var(TypeVariableOrigin {
2245 kind: TypeVariableOriginKind::TypeInference,
2254 param: Option<&ty::GenericParamDef>,
2256 ) -> &'tcx Const<'tcx> {
2257 if let Some(param) = param {
2258 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2263 self.next_const_var(ty, ConstVariableOrigin {
2264 kind: ConstVariableOriginKind::ConstInference,
2270 fn projected_ty_from_poly_trait_ref(&self,
2273 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2276 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2278 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2282 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2285 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2286 if ty.has_escaping_bound_vars() {
2287 ty // FIXME: normalization and escaping regions
2289 self.normalize_associated_types_in(span, &ty)
2293 fn set_tainted_by_errors(&self) {
2294 self.infcx.set_tainted_by_errors()
2297 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2298 self.write_ty(hir_id, ty)
2302 /// Controls whether the arguments are tupled. This is used for the call
2305 /// Tupling means that all call-side arguments are packed into a tuple and
2306 /// passed as a single parameter. For example, if tupling is enabled, this
2309 /// fn f(x: (isize, isize))
2311 /// Can be called as:
2318 #[derive(Clone, Eq, PartialEq)]
2319 enum TupleArgumentsFlag {
2324 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2326 inh: &'a Inherited<'a, 'tcx>,
2327 param_env: ty::ParamEnv<'tcx>,
2328 body_id: hir::HirId,
2329 ) -> FnCtxt<'a, 'tcx> {
2333 err_count_on_creation: inh.tcx.sess.err_count(),
2335 ret_coercion_span: RefCell::new(None),
2337 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2338 hir::CRATE_HIR_ID)),
2339 diverges: Cell::new(Diverges::Maybe),
2340 has_errors: Cell::new(false),
2341 enclosing_breakables: RefCell::new(EnclosingBreakables {
2343 by_id: Default::default(),
2349 pub fn sess(&self) -> &Session {
2353 pub fn errors_reported_since_creation(&self) -> bool {
2354 self.tcx.sess.err_count() > self.err_count_on_creation
2357 /// Produces warning on the given node, if the current point in the
2358 /// function is unreachable, and there hasn't been another warning.
2359 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2360 // FIXME: Combine these two 'if' expressions into one once
2361 // let chains are implemented
2362 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2363 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2364 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2365 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2366 if !span.is_desugaring(DesugaringKind::CondTemporary) &&
2367 !span.is_desugaring(DesugaringKind::Async)
2369 self.diverges.set(Diverges::WarnedAlways);
2371 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2373 let msg = format!("unreachable {}", kind);
2374 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2375 .span_label(span, &msg)
2378 custom_note.unwrap_or("any code following this expression is unreachable"),
2387 code: ObligationCauseCode<'tcx>)
2388 -> ObligationCause<'tcx> {
2389 ObligationCause::new(span, self.body_id, code)
2392 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2393 self.cause(span, ObligationCauseCode::MiscObligation)
2396 /// Resolves type variables in `ty` if possible. Unlike the infcx
2397 /// version (resolve_vars_if_possible), this version will
2398 /// also select obligations if it seems useful, in an effort
2399 /// to get more type information.
2400 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2401 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2403 // No Infer()? Nothing needs doing.
2404 if !ty.has_infer_types() {
2405 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2409 // If `ty` is a type variable, see whether we already know what it is.
2410 ty = self.resolve_vars_if_possible(&ty);
2411 if !ty.has_infer_types() {
2412 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2416 // If not, try resolving pending obligations as much as
2417 // possible. This can help substantially when there are
2418 // indirect dependencies that don't seem worth tracking
2420 self.select_obligations_where_possible(false, |_| {});
2421 ty = self.resolve_vars_if_possible(&ty);
2423 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2427 fn record_deferred_call_resolution(
2429 closure_def_id: DefId,
2430 r: DeferredCallResolution<'tcx>,
2432 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2433 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2436 fn remove_deferred_call_resolutions(
2438 closure_def_id: DefId,
2439 ) -> Vec<DeferredCallResolution<'tcx>> {
2440 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2441 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2444 pub fn tag(&self) -> String {
2445 format!("{:p}", self)
2448 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2449 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2450 span_bug!(span, "no type for local variable {}",
2451 self.tcx.hir().node_to_string(nid))
2456 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2457 debug!("write_ty({:?}, {:?}) in fcx {}",
2458 id, self.resolve_vars_if_possible(&ty), self.tag());
2459 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2461 if ty.references_error() {
2462 self.has_errors.set(true);
2463 self.set_tainted_by_errors();
2467 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2468 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2471 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2472 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2475 pub fn write_method_call(&self,
2477 method: MethodCallee<'tcx>) {
2478 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2479 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2480 self.write_substs(hir_id, method.substs);
2482 // When the method is confirmed, the `method.substs` includes
2483 // parameters from not just the method, but also the impl of
2484 // the method -- in particular, the `Self` type will be fully
2485 // resolved. However, those are not something that the "user
2486 // specified" -- i.e., those types come from the inferred type
2487 // of the receiver, not something the user wrote. So when we
2488 // create the user-substs, we want to replace those earlier
2489 // types with just the types that the user actually wrote --
2490 // that is, those that appear on the *method itself*.
2492 // As an example, if the user wrote something like
2493 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2494 // type of `foo` (possibly adjusted), but we don't want to
2495 // include that. We want just the `[_, u32]` part.
2496 if !method.substs.is_noop() {
2497 let method_generics = self.tcx.generics_of(method.def_id);
2498 if !method_generics.params.is_empty() {
2499 let user_type_annotation = self.infcx.probe(|_| {
2500 let user_substs = UserSubsts {
2501 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2502 let i = param.index as usize;
2503 if i < method_generics.parent_count {
2504 self.infcx.var_for_def(DUMMY_SP, param)
2509 user_self_ty: None, // not relevant here
2512 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2518 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2519 self.write_user_type_annotation(hir_id, user_type_annotation);
2524 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2525 if !substs.is_noop() {
2526 debug!("write_substs({:?}, {:?}) in fcx {}",
2531 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2535 /// Given the substs that we just converted from the HIR, try to
2536 /// canonicalize them and store them as user-given substitutions
2537 /// (i.e., substitutions that must be respected by the NLL check).
2539 /// This should be invoked **before any unifications have
2540 /// occurred**, so that annotations like `Vec<_>` are preserved
2542 pub fn write_user_type_annotation_from_substs(
2546 substs: SubstsRef<'tcx>,
2547 user_self_ty: Option<UserSelfTy<'tcx>>,
2550 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2551 user_self_ty={:?} in fcx {}",
2552 hir_id, def_id, substs, user_self_ty, self.tag(),
2555 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2556 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2557 &UserType::TypeOf(def_id, UserSubsts {
2562 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2563 self.write_user_type_annotation(hir_id, canonicalized);
2567 pub fn write_user_type_annotation(
2570 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2573 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2574 hir_id, canonical_user_type_annotation, self.tag(),
2577 if !canonical_user_type_annotation.is_identity() {
2578 self.tables.borrow_mut().user_provided_types_mut().insert(
2579 hir_id, canonical_user_type_annotation
2582 debug!("write_user_type_annotation: skipping identity substs");
2586 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2587 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2593 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2594 Entry::Vacant(entry) => { entry.insert(adj); },
2595 Entry::Occupied(mut entry) => {
2596 debug!(" - composing on top of {:?}", entry.get());
2597 match (&entry.get()[..], &adj[..]) {
2598 // Applying any adjustment on top of a NeverToAny
2599 // is a valid NeverToAny adjustment, because it can't
2601 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2603 Adjustment { kind: Adjust::Deref(_), .. },
2604 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2606 Adjustment { kind: Adjust::Deref(_), .. },
2607 .. // Any following adjustments are allowed.
2609 // A reborrow has no effect before a dereference.
2611 // FIXME: currently we never try to compose autoderefs
2612 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2614 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2615 expr, entry.get(), adj)
2617 *entry.get_mut() = adj;
2622 /// Basically whenever we are converting from a type scheme into
2623 /// the fn body space, we always want to normalize associated
2624 /// types as well. This function combines the two.
2625 fn instantiate_type_scheme<T>(&self,
2627 substs: SubstsRef<'tcx>,
2630 where T : TypeFoldable<'tcx>
2632 let value = value.subst(self.tcx, substs);
2633 let result = self.normalize_associated_types_in(span, &value);
2634 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2641 /// As `instantiate_type_scheme`, but for the bounds found in a
2642 /// generic type scheme.
2643 fn instantiate_bounds(
2647 substs: SubstsRef<'tcx>,
2648 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
2649 let bounds = self.tcx.predicates_of(def_id);
2650 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
2651 let result = bounds.instantiate(self.tcx, substs);
2652 let result = self.normalize_associated_types_in(span, &result);
2654 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
2663 /// Replaces the opaque types from the given value with type variables,
2664 /// and records the `OpaqueTypeMap` for later use during writeback. See
2665 /// `InferCtxt::instantiate_opaque_types` for more details.
2666 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2668 parent_id: hir::HirId,
2672 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2673 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2677 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2678 self.instantiate_opaque_types(
2687 let mut opaque_types = self.opaque_types.borrow_mut();
2688 for (ty, decl) in opaque_type_map {
2689 let old_value = opaque_types.insert(ty, decl);
2690 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2696 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2697 where T : TypeFoldable<'tcx>
2699 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2702 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2704 where T : TypeFoldable<'tcx>
2706 self.inh.partially_normalize_associated_types_in(span,
2712 pub fn require_type_meets(&self,
2715 code: traits::ObligationCauseCode<'tcx>,
2718 self.register_bound(
2721 traits::ObligationCause::new(span, self.body_id, code));
2724 pub fn require_type_is_sized(
2728 code: traits::ObligationCauseCode<'tcx>,
2730 if !ty.references_error() {
2731 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
2732 self.require_type_meets(ty, span, code, lang_item);
2736 pub fn require_type_is_sized_deferred(
2740 code: traits::ObligationCauseCode<'tcx>,
2742 if !ty.references_error() {
2743 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2747 pub fn register_bound(
2751 cause: traits::ObligationCause<'tcx>,
2753 if !ty.references_error() {
2754 self.fulfillment_cx.borrow_mut()
2755 .register_bound(self, self.param_env, ty, def_id, cause);
2759 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2760 let t = AstConv::ast_ty_to_ty(self, ast_t);
2761 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2765 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2766 let ty = self.to_ty(ast_ty);
2767 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2769 if Self::can_contain_user_lifetime_bounds(ty) {
2770 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2771 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2772 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2778 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2779 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2780 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2783 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2784 AstConv::ast_const_to_const(self, ast_c, ty)
2787 // If the type given by the user has free regions, save it for later, since
2788 // NLL would like to enforce those. Also pass in types that involve
2789 // projections, since those can resolve to `'static` bounds (modulo #54940,
2790 // which hopefully will be fixed by the time you see this comment, dear
2791 // reader, although I have my doubts). Also pass in types with inference
2792 // types, because they may be repeated. Other sorts of things are already
2793 // sufficiently enforced with erased regions. =)
2794 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2796 T: TypeFoldable<'tcx>
2798 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2801 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2802 match self.tables.borrow().node_types().get(id) {
2804 None if self.is_tainted_by_errors() => self.tcx.types.err,
2806 bug!("no type for node {}: {} in fcx {}",
2807 id, self.tcx.hir().node_to_string(id),
2813 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2814 /// outlive the region `r`.
2815 pub fn register_wf_obligation(
2819 code: traits::ObligationCauseCode<'tcx>,
2821 // WF obligations never themselves fail, so no real need to give a detailed cause:
2822 let cause = traits::ObligationCause::new(span, self.body_id, code);
2823 self.register_predicate(
2824 traits::Obligation::new(cause, self.param_env, ty::Predicate::WellFormed(ty)),
2828 /// Registers obligations that all types appearing in `substs` are well-formed.
2829 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2830 for ty in substs.types() {
2831 if !ty.references_error() {
2832 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2837 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2838 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2839 /// trait/region obligations.
2841 /// For example, if there is a function:
2844 /// fn foo<'a,T:'a>(...)
2847 /// and a reference:
2853 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2854 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2855 pub fn add_obligations_for_parameters(&self,
2856 cause: traits::ObligationCause<'tcx>,
2857 predicates: &ty::InstantiatedPredicates<'tcx>)
2859 assert!(!predicates.has_escaping_bound_vars());
2861 debug!("add_obligations_for_parameters(predicates={:?})",
2864 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2865 self.register_predicate(obligation);
2869 // FIXME(arielb1): use this instead of field.ty everywhere
2870 // Only for fields! Returns <none> for methods>
2871 // Indifferent to privacy flags
2875 field: &'tcx ty::FieldDef,
2876 substs: SubstsRef<'tcx>,
2878 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2881 fn check_casts(&self) {
2882 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2883 for cast in deferred_cast_checks.drain(..) {
2888 fn resolve_generator_interiors(&self, def_id: DefId) {
2889 let mut generators = self.deferred_generator_interiors.borrow_mut();
2890 for (body_id, interior, kind) in generators.drain(..) {
2891 self.select_obligations_where_possible(false, |_| {});
2892 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2896 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2897 // Non-numerics get replaced with ! or () (depending on whether
2898 // feature(never_type) is enabled, unconstrained ints with i32,
2899 // unconstrained floats with f64.
2900 // Fallback becomes very dubious if we have encountered type-checking errors.
2901 // In that case, fallback to Error.
2902 // The return value indicates whether fallback has occurred.
2903 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2904 use rustc::ty::error::UnconstrainedNumeric::Neither;
2905 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2907 assert!(ty.is_ty_infer());
2908 let fallback = match self.type_is_unconstrained_numeric(ty) {
2909 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2910 UnconstrainedInt => self.tcx.types.i32,
2911 UnconstrainedFloat => self.tcx.types.f64,
2912 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2913 Neither => return false,
2915 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2916 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2920 fn select_all_obligations_or_error(&self) {
2921 debug!("select_all_obligations_or_error");
2922 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2923 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2927 /// Select as many obligations as we can at present.
2928 fn select_obligations_where_possible(
2930 fallback_has_occurred: bool,
2931 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
2933 if let Err(mut errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2934 mutate_fullfillment_errors(&mut errors);
2935 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2939 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2940 /// returns a type of `&T`, but the actual type we assign to the
2941 /// *expression* is `T`. So this function just peels off the return
2942 /// type by one layer to yield `T`.
2943 fn make_overloaded_place_return_type(&self,
2944 method: MethodCallee<'tcx>)
2945 -> ty::TypeAndMut<'tcx>
2947 // extract method return type, which will be &T;
2948 let ret_ty = method.sig.output();
2950 // method returns &T, but the type as visible to user is T, so deref
2951 ret_ty.builtin_deref(true).unwrap()
2957 base_expr: &'tcx hir::Expr,
2961 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2962 // FIXME(#18741) -- this is almost but not quite the same as the
2963 // autoderef that normal method probing does. They could likely be
2966 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2967 let mut result = None;
2968 while result.is_none() && autoderef.next().is_some() {
2969 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2971 autoderef.finalize(self);
2975 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2976 /// (and otherwise adjust) `base_expr`, looking for a type which either
2977 /// supports builtin indexing or overloaded indexing.
2978 /// This loop implements one step in that search; the autoderef loop
2979 /// is implemented by `lookup_indexing`.
2983 base_expr: &hir::Expr,
2984 autoderef: &Autoderef<'a, 'tcx>,
2987 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2988 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2989 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2996 for &unsize in &[false, true] {
2997 let mut self_ty = adjusted_ty;
2999 // We only unsize arrays here.
3000 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3001 self_ty = self.tcx.mk_slice(element_ty);
3007 // If some lookup succeeds, write callee into table and extract index/element
3008 // type from the method signature.
3009 // If some lookup succeeded, install method in table
3010 let input_ty = self.next_ty_var(TypeVariableOrigin {
3011 kind: TypeVariableOriginKind::AutoDeref,
3012 span: base_expr.span,
3014 let method = self.try_overloaded_place_op(
3015 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
3017 let result = method.map(|ok| {
3018 debug!("try_index_step: success, using overloaded indexing");
3019 let method = self.register_infer_ok_obligations(ok);
3021 let mut adjustments = autoderef.adjust_steps(self, needs);
3022 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3023 let mutbl = match r_mutbl {
3024 hir::MutImmutable => AutoBorrowMutability::Immutable,
3025 hir::MutMutable => AutoBorrowMutability::Mutable {
3026 // Indexing can be desugared to a method call,
3027 // so maybe we could use two-phase here.
3028 // See the documentation of AllowTwoPhase for why that's
3029 // not the case today.
3030 allow_two_phase_borrow: AllowTwoPhase::No,
3033 adjustments.push(Adjustment {
3034 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3035 target: self.tcx.mk_ref(region, ty::TypeAndMut {
3042 adjustments.push(Adjustment {
3043 kind: Adjust::Pointer(PointerCast::Unsize),
3044 target: method.sig.inputs()[0]
3047 self.apply_adjustments(base_expr, adjustments);
3049 self.write_method_call(expr.hir_id, method);
3050 (input_ty, self.make_overloaded_place_return_type(method).ty)
3052 if result.is_some() {
3060 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3061 let (tr, name) = match (op, is_mut) {
3062 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3063 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3064 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3065 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3067 (tr, ast::Ident::with_dummy_span(name))
3070 fn try_overloaded_place_op(&self,
3073 arg_tys: &[Ty<'tcx>],
3076 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3078 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3084 // Try Mut first, if needed.
3085 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3086 let method = match (needs, mut_tr) {
3087 (Needs::MutPlace, Some(trait_did)) => {
3088 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3093 // Otherwise, fall back to the immutable version.
3094 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3095 let method = match (method, imm_tr) {
3096 (None, Some(trait_did)) => {
3097 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3099 (method, _) => method,
3105 fn check_method_argument_types(
3108 expr: &'tcx hir::Expr,
3109 method: Result<MethodCallee<'tcx>, ()>,
3110 args_no_rcvr: &'tcx [hir::Expr],
3111 tuple_arguments: TupleArgumentsFlag,
3112 expected: Expectation<'tcx>,
3115 let has_error = match method {
3117 method.substs.references_error() || method.sig.references_error()
3122 let err_inputs = self.err_args(args_no_rcvr.len());
3124 let err_inputs = match tuple_arguments {
3125 DontTupleArguments => err_inputs,
3126 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3129 self.check_argument_types(
3139 return self.tcx.types.err;
3142 let method = method.unwrap();
3143 // HACK(eddyb) ignore self in the definition (see above).
3144 let expected_arg_tys = self.expected_inputs_for_expected_output(
3147 method.sig.output(),
3148 &method.sig.inputs()[1..]
3150 self.check_argument_types(
3153 &method.sig.inputs()[1..],
3154 &expected_arg_tys[..],
3156 method.sig.c_variadic,
3158 self.tcx.hir().span_if_local(method.def_id),
3163 fn self_type_matches_expected_vid(
3165 trait_ref: ty::PolyTraitRef<'tcx>,
3166 expected_vid: ty::TyVid,
3168 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3170 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3171 trait_ref, self_ty, expected_vid
3173 match self_ty.kind {
3174 ty::Infer(ty::TyVar(found_vid)) => {
3175 // FIXME: consider using `sub_root_var` here so we
3176 // can see through subtyping.
3177 let found_vid = self.root_var(found_vid);
3178 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3179 expected_vid == found_vid
3185 fn obligations_for_self_ty<'b>(
3188 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3191 // FIXME: consider using `sub_root_var` here so we
3192 // can see through subtyping.
3193 let ty_var_root = self.root_var(self_ty);
3194 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3195 self_ty, ty_var_root,
3196 self.fulfillment_cx.borrow().pending_obligations());
3200 .pending_obligations()
3202 .filter_map(move |obligation| match obligation.predicate {
3203 ty::Predicate::Projection(ref data) =>
3204 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3205 ty::Predicate::Trait(ref data) =>
3206 Some((data.to_poly_trait_ref(), obligation)),
3207 ty::Predicate::Subtype(..) => None,
3208 ty::Predicate::RegionOutlives(..) => None,
3209 ty::Predicate::TypeOutlives(..) => None,
3210 ty::Predicate::WellFormed(..) => None,
3211 ty::Predicate::ObjectSafe(..) => None,
3212 ty::Predicate::ConstEvaluatable(..) => None,
3213 // N.B., this predicate is created by breaking down a
3214 // `ClosureType: FnFoo()` predicate, where
3215 // `ClosureType` represents some `Closure`. It can't
3216 // possibly be referring to the current closure,
3217 // because we haven't produced the `Closure` for
3218 // this closure yet; this is exactly why the other
3219 // code is looking for a self type of a unresolved
3220 // inference variable.
3221 ty::Predicate::ClosureKind(..) => None,
3222 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3225 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3226 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3227 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3231 /// Generic function that factors out common logic from function calls,
3232 /// method calls and overloaded operators.
3233 fn check_argument_types(
3236 expr: &'tcx hir::Expr,
3237 fn_inputs: &[Ty<'tcx>],
3238 expected_arg_tys: &[Ty<'tcx>],
3239 args: &'tcx [hir::Expr],
3241 tuple_arguments: TupleArgumentsFlag,
3242 def_span: Option<Span>,
3245 // Grab the argument types, supplying fresh type variables
3246 // if the wrong number of arguments were supplied
3247 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3253 // All the input types from the fn signature must outlive the call
3254 // so as to validate implied bounds.
3255 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3256 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3259 let expected_arg_count = fn_inputs.len();
3261 let param_count_error = |expected_count: usize,
3266 let mut err = tcx.sess.struct_span_err_with_code(sp,
3267 &format!("this function takes {}{} but {} {} supplied",
3268 if c_variadic { "at least " } else { "" },
3269 potentially_plural_count(expected_count, "parameter"),
3270 potentially_plural_count(arg_count, "parameter"),
3271 if arg_count == 1 {"was"} else {"were"}),
3272 DiagnosticId::Error(error_code.to_owned()));
3274 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3275 err.span_label(def_s, "defined here");
3278 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3279 // remove closing `)` from the span
3280 let sugg_span = sugg_span.shrink_to_lo();
3281 err.span_suggestion(
3283 "expected the unit value `()`; create it with empty parentheses",
3285 Applicability::MachineApplicable);
3287 err.span_label(sp, format!("expected {}{}",
3288 if c_variadic { "at least " } else { "" },
3289 potentially_plural_count(expected_count, "parameter")));
3294 let mut expected_arg_tys = expected_arg_tys.to_vec();
3296 let formal_tys = if tuple_arguments == TupleArguments {
3297 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3298 match tuple_type.kind {
3299 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3300 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3301 expected_arg_tys = vec![];
3302 self.err_args(args.len())
3304 ty::Tuple(arg_types) => {
3305 expected_arg_tys = match expected_arg_tys.get(0) {
3306 Some(&ty) => match ty.kind {
3307 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3312 arg_types.iter().map(|k| k.expect_ty()).collect()
3315 span_err!(tcx.sess, sp, E0059,
3316 "cannot use call notation; the first type parameter \
3317 for the function trait is neither a tuple nor unit");
3318 expected_arg_tys = vec![];
3319 self.err_args(args.len())
3322 } else if expected_arg_count == supplied_arg_count {
3324 } else if c_variadic {
3325 if supplied_arg_count >= expected_arg_count {
3328 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3329 expected_arg_tys = vec![];
3330 self.err_args(supplied_arg_count)
3333 // is the missing argument of type `()`?
3334 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3335 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3336 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3337 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3341 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3343 expected_arg_tys = vec![];
3344 self.err_args(supplied_arg_count)
3347 debug!("check_argument_types: formal_tys={:?}",
3348 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3350 // If there is no expectation, expect formal_tys.
3351 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3357 let mut final_arg_types: Vec<(usize, Ty<'_>)> = vec![];
3359 // Check the arguments.
3360 // We do this in a pretty awful way: first we type-check any arguments
3361 // that are not closures, then we type-check the closures. This is so
3362 // that we have more information about the types of arguments when we
3363 // type-check the functions. This isn't really the right way to do this.
3364 for &check_closures in &[false, true] {
3365 debug!("check_closures={}", check_closures);
3367 // More awful hacks: before we check argument types, try to do
3368 // an "opportunistic" vtable resolution of any trait bounds on
3369 // the call. This helps coercions.
3371 self.select_obligations_where_possible(false, |errors| {
3372 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3373 self.point_at_arg_instead_of_call_if_possible(
3375 &final_arg_types[..],
3382 // For C-variadic functions, we don't have a declared type for all of
3383 // the arguments hence we only do our usual type checking with
3384 // the arguments who's types we do know.
3385 let t = if c_variadic {
3387 } else if tuple_arguments == TupleArguments {
3392 for (i, arg) in args.iter().take(t).enumerate() {
3393 // Warn only for the first loop (the "no closures" one).
3394 // Closure arguments themselves can't be diverging, but
3395 // a previous argument can, e.g., `foo(panic!(), || {})`.
3396 if !check_closures {
3397 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3400 let is_closure = match arg.kind {
3401 ExprKind::Closure(..) => true,
3405 if is_closure != check_closures {
3409 debug!("checking the argument");
3410 let formal_ty = formal_tys[i];
3412 // The special-cased logic below has three functions:
3413 // 1. Provide as good of an expected type as possible.
3414 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3416 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3418 // 2. Coerce to the most detailed type that could be coerced
3419 // to, which is `expected_ty` if `rvalue_hint` returns an
3420 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3421 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3422 // We're processing function arguments so we definitely want to use
3423 // two-phase borrows.
3424 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3425 final_arg_types.push((i, coerce_ty));
3427 // 3. Relate the expected type and the formal one,
3428 // if the expected type was used for the coercion.
3429 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3433 // We also need to make sure we at least write the ty of the other
3434 // arguments which we skipped above.
3436 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3437 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3438 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3441 for arg in args.iter().skip(expected_arg_count) {
3442 let arg_ty = self.check_expr(&arg);
3444 // There are a few types which get autopromoted when passed via varargs
3445 // in C but we just error out instead and require explicit casts.
3446 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3448 ty::Float(ast::FloatTy::F32) => {
3449 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3451 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3452 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3454 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3455 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3458 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3459 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3460 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3468 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3469 vec![self.tcx.types.err; len]
3472 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call argument expressions, we
3473 /// walk the resolved types for each argument to see if any of the `FullfillmentError`s
3474 /// reference a type argument. If they do, and there's only *one* argument that does, we point
3475 /// at the corresponding argument's expression span instead of the `fn` call path span.
3476 fn point_at_arg_instead_of_call_if_possible(
3478 errors: &mut Vec<traits::FulfillmentError<'_>>,
3479 final_arg_types: &[(usize, Ty<'tcx>)],
3481 args: &'tcx [hir::Expr],
3483 if !call_sp.desugaring_kind().is_some() {
3484 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3485 // the `?` operator.
3486 for error in errors {
3487 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3488 // Collect the argument position for all arguments that could have caused this
3489 // `FullfillmentError`.
3490 let mut referenced_in = final_arg_types.iter()
3491 .flat_map(|(i, ty)| {
3492 let ty = self.resolve_vars_if_possible(ty);
3493 // We walk the argument type because the argument's type could have
3494 // been `Option<T>`, but the `FullfillmentError` references `T`.
3496 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3499 if let (Some(ref_in), None) = (referenced_in.next(), referenced_in.next()) {
3500 // We make sure that only *one* argument matches the obligation failure
3501 // and thet the obligation's span to its expression's.
3502 error.obligation.cause.span = args[ref_in].span;
3503 error.points_at_arg_span = true;
3510 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call expression, we walk the
3511 /// `PathSegment`s and resolve their type parameters to see if any of the `FullfillmentError`s
3512 /// were caused by them. If they were, we point at the corresponding type argument's span
3513 /// instead of the `fn` call path span.
3514 fn point_at_type_arg_instead_of_call_if_possible(
3516 errors: &mut Vec<traits::FulfillmentError<'_>>,
3517 call_expr: &'tcx hir::Expr,
3519 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3520 if let hir::ExprKind::Path(qpath) = &path.kind {
3521 if let hir::QPath::Resolved(_, path) = &qpath {
3522 for error in errors {
3523 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3524 // If any of the type arguments in this path segment caused the
3525 // `FullfillmentError`, point at its span (#61860).
3526 for arg in path.segments.iter()
3527 .filter_map(|seg| seg.args.as_ref())
3528 .flat_map(|a| a.args.iter())
3530 if let hir::GenericArg::Type(hir_ty) = &arg {
3531 if let hir::TyKind::Path(
3532 hir::QPath::TypeRelative(..),
3534 // Avoid ICE with associated types. As this is best
3535 // effort only, it's ok to ignore the case. It
3536 // would trigger in `is_send::<T::AssocType>();`
3537 // from `typeck-default-trait-impl-assoc-type.rs`.
3539 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
3540 let ty = self.resolve_vars_if_possible(&ty);
3541 if ty == predicate.skip_binder().self_ty() {
3542 error.obligation.cause.span = hir_ty.span;
3554 // AST fragment checking
3557 expected: Expectation<'tcx>)
3563 ast::LitKind::Str(..) => tcx.mk_static_str(),
3564 ast::LitKind::ByteStr(ref v) => {
3565 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3566 tcx.mk_array(tcx.types.u8, v.len() as u64))
3568 ast::LitKind::Byte(_) => tcx.types.u8,
3569 ast::LitKind::Char(_) => tcx.types.char,
3570 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3571 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3572 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3573 let opt_ty = expected.to_option(self).and_then(|ty| {
3575 ty::Int(_) | ty::Uint(_) => Some(ty),
3576 ty::Char => Some(tcx.types.u8),
3577 ty::RawPtr(..) => Some(tcx.types.usize),
3578 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3582 opt_ty.unwrap_or_else(|| self.next_int_var())
3584 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3585 ast::LitKind::FloatUnsuffixed(_) => {
3586 let opt_ty = expected.to_option(self).and_then(|ty| {
3588 ty::Float(_) => Some(ty),
3592 opt_ty.unwrap_or_else(|| self.next_float_var())
3594 ast::LitKind::Bool(_) => tcx.types.bool,
3595 ast::LitKind::Err(_) => tcx.types.err,
3599 // Determine the `Self` type, using fresh variables for all variables
3600 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3601 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3603 pub fn impl_self_ty(&self,
3604 span: Span, // (potential) receiver for this impl
3606 -> TypeAndSubsts<'tcx> {
3607 let ity = self.tcx.type_of(did);
3608 debug!("impl_self_ty: ity={:?}", ity);
3610 let substs = self.fresh_substs_for_item(span, did);
3611 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3613 TypeAndSubsts { substs: substs, ty: substd_ty }
3616 /// Unifies the output type with the expected type early, for more coercions
3617 /// and forward type information on the input expressions.
3618 fn expected_inputs_for_expected_output(&self,
3620 expected_ret: Expectation<'tcx>,
3621 formal_ret: Ty<'tcx>,
3622 formal_args: &[Ty<'tcx>])
3624 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3625 let ret_ty = match expected_ret.only_has_type(self) {
3627 None => return Vec::new()
3629 let expect_args = self.fudge_inference_if_ok(|| {
3630 // Attempt to apply a subtyping relationship between the formal
3631 // return type (likely containing type variables if the function
3632 // is polymorphic) and the expected return type.
3633 // No argument expectations are produced if unification fails.
3634 let origin = self.misc(call_span);
3635 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3637 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3638 // to identity so the resulting type is not constrained.
3641 // Process any obligations locally as much as
3642 // we can. We don't care if some things turn
3643 // out unconstrained or ambiguous, as we're
3644 // just trying to get hints here.
3645 self.save_and_restore_in_snapshot_flag(|_| {
3646 let mut fulfill = TraitEngine::new(self.tcx);
3647 for obligation in ok.obligations {
3648 fulfill.register_predicate_obligation(self, obligation);
3650 fulfill.select_where_possible(self)
3651 }).map_err(|_| ())?;
3653 Err(_) => return Err(()),
3656 // Record all the argument types, with the substitutions
3657 // produced from the above subtyping unification.
3658 Ok(formal_args.iter().map(|ty| {
3659 self.resolve_vars_if_possible(ty)
3661 }).unwrap_or_default();
3662 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3663 formal_args, formal_ret,
3664 expect_args, expected_ret);
3668 pub fn check_struct_path(&self,
3671 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3672 let path_span = match *qpath {
3673 QPath::Resolved(_, ref path) => path.span,
3674 QPath::TypeRelative(ref qself, _) => qself.span
3676 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3677 let variant = match def {
3679 self.set_tainted_by_errors();
3682 Res::Def(DefKind::Variant, _) => {
3684 ty::Adt(adt, substs) => {
3685 Some((adt.variant_of_res(def), adt.did, substs))
3687 _ => bug!("unexpected type: {:?}", ty)
3690 Res::Def(DefKind::Struct, _)
3691 | Res::Def(DefKind::Union, _)
3692 | Res::Def(DefKind::TyAlias, _)
3693 | Res::Def(DefKind::AssocTy, _)
3694 | Res::SelfTy(..) => {
3696 ty::Adt(adt, substs) if !adt.is_enum() => {
3697 Some((adt.non_enum_variant(), adt.did, substs))
3702 _ => bug!("unexpected definition: {:?}", def)
3705 if let Some((variant, did, substs)) = variant {
3706 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3707 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3709 // Check bounds on type arguments used in the path.
3710 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
3711 let cause = traits::ObligationCause::new(
3714 traits::ItemObligation(did),
3716 self.add_obligations_for_parameters(cause, &bounds);
3720 struct_span_err!(self.tcx.sess, path_span, E0071,
3721 "expected struct, variant or union type, found {}",
3722 ty.sort_string(self.tcx))
3723 .span_label(path_span, "not a struct")
3729 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3730 // The newly resolved definition is written into `type_dependent_defs`.
3731 fn finish_resolving_struct_path(&self,
3738 QPath::Resolved(ref maybe_qself, ref path) => {
3739 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3740 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3743 QPath::TypeRelative(ref qself, ref segment) => {
3744 let ty = self.to_ty(qself);
3746 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
3751 let result = AstConv::associated_path_to_ty(
3760 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3761 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3763 // Write back the new resolution.
3764 self.write_resolution(hir_id, result);
3766 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3771 /// Resolves an associated value path into a base type and associated constant, or method
3772 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3773 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3777 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3779 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3780 let (ty, qself, item_segment) = match *qpath {
3781 QPath::Resolved(ref opt_qself, ref path) => {
3783 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3784 &path.segments[..]);
3786 QPath::TypeRelative(ref qself, ref segment) => {
3787 (self.to_ty(qself), qself, segment)
3790 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3791 // Return directly on cache hit. This is useful to avoid doubly reporting
3792 // errors with default match binding modes. See #44614.
3793 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3794 .unwrap_or(Res::Err);
3795 return (def, Some(ty), slice::from_ref(&**item_segment));
3797 let item_name = item_segment.ident;
3798 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3799 let result = match error {
3800 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3801 _ => Err(ErrorReported),
3803 if item_name.name != kw::Invalid {
3804 self.report_method_error(
3808 SelfSource::QPath(qself),
3811 ).map(|mut e| e.emit());
3816 // Write back the new resolution.
3817 self.write_resolution(hir_id, result);
3819 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3821 slice::from_ref(&**item_segment),
3825 pub fn check_decl_initializer(
3827 local: &'tcx hir::Local,
3828 init: &'tcx hir::Expr,
3830 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3831 // for #42640 (default match binding modes).
3834 let ref_bindings = local.pat.contains_explicit_ref_binding();
3836 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3837 if let Some(m) = ref_bindings {
3838 // Somewhat subtle: if we have a `ref` binding in the pattern,
3839 // we want to avoid introducing coercions for the RHS. This is
3840 // both because it helps preserve sanity and, in the case of
3841 // ref mut, for soundness (issue #23116). In particular, in
3842 // the latter case, we need to be clear that the type of the
3843 // referent for the reference that results is *equal to* the
3844 // type of the place it is referencing, and not some
3845 // supertype thereof.
3846 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3847 self.demand_eqtype(init.span, local_ty, init_ty);
3850 self.check_expr_coercable_to_type(init, local_ty)
3854 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3855 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3856 self.write_ty(local.hir_id, t);
3858 if let Some(ref init) = local.init {
3859 let init_ty = self.check_decl_initializer(local, &init);
3860 self.overwrite_local_ty_if_err(local, t, init_ty);
3863 self.check_pat_top(&local.pat, t, None);
3864 let pat_ty = self.node_ty(local.pat.hir_id);
3865 self.overwrite_local_ty_if_err(local, t, pat_ty);
3868 fn overwrite_local_ty_if_err(&self, local: &'tcx hir::Local, decl_ty: Ty<'tcx>, ty: Ty<'tcx>) {
3869 if ty.references_error() {
3870 // Override the types everywhere with `types.err` to avoid knock down errors.
3871 self.write_ty(local.hir_id, ty);
3872 self.write_ty(local.pat.hir_id, ty);
3873 let local_ty = LocalTy {
3877 self.locals.borrow_mut().insert(local.hir_id, local_ty);
3878 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
3882 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3883 // Don't do all the complex logic below for `DeclItem`.
3885 hir::StmtKind::Item(..) => return,
3886 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3889 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3891 // Hide the outer diverging and `has_errors` flags.
3892 let old_diverges = self.diverges.get();
3893 let old_has_errors = self.has_errors.get();
3894 self.diverges.set(Diverges::Maybe);
3895 self.has_errors.set(false);
3898 hir::StmtKind::Local(ref l) => {
3899 self.check_decl_local(&l);
3902 hir::StmtKind::Item(_) => {}
3903 hir::StmtKind::Expr(ref expr) => {
3904 // Check with expected type of `()`.
3905 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3907 hir::StmtKind::Semi(ref expr) => {
3908 self.check_expr(&expr);
3912 // Combine the diverging and `has_error` flags.
3913 self.diverges.set(self.diverges.get() | old_diverges);
3914 self.has_errors.set(self.has_errors.get() | old_has_errors);
3917 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3918 let unit = self.tcx.mk_unit();
3919 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3921 // if the block produces a `!` value, that can always be
3922 // (effectively) coerced to unit.
3924 self.demand_suptype(blk.span, unit, ty);
3928 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
3929 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
3930 /// when given code like the following:
3932 /// if false { return 0i32; } else { 1u32 }
3933 /// // ^^^^ point at this instead of the whole `if` expression
3935 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
3936 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
3937 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
3938 self.in_progress_tables
3939 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
3940 .and_then(|arm_ty| {
3941 if arm_ty.is_never() {
3944 Some(match &arm.body.kind {
3945 // Point at the tail expression when possible.
3946 hir::ExprKind::Block(block, _) => block.expr
3949 .unwrap_or(block.span),
3955 if arm_spans.len() == 1 {
3956 return arm_spans[0];
3962 fn check_block_with_expected(
3964 blk: &'tcx hir::Block,
3965 expected: Expectation<'tcx>,
3968 let mut fcx_ps = self.ps.borrow_mut();
3969 let unsafety_state = fcx_ps.recurse(blk);
3970 replace(&mut *fcx_ps, unsafety_state)
3973 // In some cases, blocks have just one exit, but other blocks
3974 // can be targeted by multiple breaks. This can happen both
3975 // with labeled blocks as well as when we desugar
3976 // a `try { ... }` expression.
3980 // 'a: { if true { break 'a Err(()); } Ok(()) }
3982 // Here we would wind up with two coercions, one from
3983 // `Err(())` and the other from the tail expression
3984 // `Ok(())`. If the tail expression is omitted, that's a
3985 // "forced unit" -- unless the block diverges, in which
3986 // case we can ignore the tail expression (e.g., `'a: {
3987 // break 'a 22; }` would not force the type of the block
3989 let tail_expr = blk.expr.as_ref();
3990 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3991 let coerce = if blk.targeted_by_break {
3992 CoerceMany::new(coerce_to_ty)
3994 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3995 Some(e) => slice::from_ref(e),
3998 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4001 let prev_diverges = self.diverges.get();
4002 let ctxt = BreakableCtxt {
4003 coerce: Some(coerce),
4007 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4008 for s in &blk.stmts {
4012 // check the tail expression **without** holding the
4013 // `enclosing_breakables` lock below.
4014 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4016 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4017 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4018 let coerce = ctxt.coerce.as_mut().unwrap();
4019 if let Some(tail_expr_ty) = tail_expr_ty {
4020 let tail_expr = tail_expr.unwrap();
4021 let span = self.get_expr_coercion_span(tail_expr);
4022 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4023 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4025 // Subtle: if there is no explicit tail expression,
4026 // that is typically equivalent to a tail expression
4027 // of `()` -- except if the block diverges. In that
4028 // case, there is no value supplied from the tail
4029 // expression (assuming there are no other breaks,
4030 // this implies that the type of the block will be
4033 // #41425 -- label the implicit `()` as being the
4034 // "found type" here, rather than the "expected type".
4035 if !self.diverges.get().is_always() {
4036 // #50009 -- Do not point at the entire fn block span, point at the return type
4037 // span, as it is the cause of the requirement, and
4038 // `consider_hint_about_removing_semicolon` will point at the last expression
4039 // if it were a relevant part of the error. This improves usability in editors
4040 // that highlight errors inline.
4041 let mut sp = blk.span;
4042 let mut fn_span = None;
4043 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4044 let ret_sp = decl.output.span();
4045 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4046 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4047 // output would otherwise be incorrect and even misleading. Make sure
4048 // the span we're aiming at correspond to a `fn` body.
4049 if block_sp == blk.span {
4051 fn_span = Some(ident.span);
4055 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4056 if let Some(expected_ty) = expected.only_has_type(self) {
4057 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4059 if let Some(fn_span) = fn_span {
4062 "implicitly returns `()` as its body has no tail or `return` \
4072 // If we can break from the block, then the block's exit is always reachable
4073 // (... as long as the entry is reachable) - regardless of the tail of the block.
4074 self.diverges.set(prev_diverges);
4077 let mut ty = ctxt.coerce.unwrap().complete(self);
4079 if self.has_errors.get() || ty.references_error() {
4080 ty = self.tcx.types.err
4083 self.write_ty(blk.hir_id, ty);
4085 *self.ps.borrow_mut() = prev;
4089 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4090 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4092 Node::Item(&hir::Item {
4093 kind: hir::ItemKind::Fn(_, _, _, body_id), ..
4095 Node::ImplItem(&hir::ImplItem {
4096 kind: hir::ImplItemKind::Method(_, body_id), ..
4098 let body = self.tcx.hir().body(body_id);
4099 if let ExprKind::Block(block, _) = &body.value.kind {
4100 return Some(block.span);
4108 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4109 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
4110 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4111 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4114 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4115 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
4117 Node::Item(&hir::Item {
4118 ident, kind: hir::ItemKind::Fn(ref decl, ..), ..
4120 // This is less than ideal, it will not suggest a return type span on any
4121 // method called `main`, regardless of whether it is actually the entry point,
4122 // but it will still present it as the reason for the expected type.
4123 Some((decl, ident, ident.name != sym::main))
4125 Node::TraitItem(&hir::TraitItem {
4126 ident, kind: hir::TraitItemKind::Method(hir::MethodSig {
4129 }) => Some((decl, ident, true)),
4130 Node::ImplItem(&hir::ImplItem {
4131 ident, kind: hir::ImplItemKind::Method(hir::MethodSig {
4134 }) => Some((decl, ident, false)),
4139 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4140 /// suggestion can be made, `None` otherwise.
4141 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
4142 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4143 // `while` before reaching it, as block tail returns are not available in them.
4144 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4145 let parent = self.tcx.hir().get(blk_id);
4146 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4150 /// On implicit return expressions with mismatched types, provides the following suggestions:
4152 /// - Points out the method's return type as the reason for the expected type.
4153 /// - Possible missing semicolon.
4154 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4155 pub fn suggest_mismatched_types_on_tail(
4157 err: &mut DiagnosticBuilder<'tcx>,
4158 expression: &'tcx hir::Expr,
4164 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4165 let mut pointing_at_return_type = false;
4166 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4167 pointing_at_return_type = self.suggest_missing_return_type(
4168 err, &fn_decl, expected, found, can_suggest);
4170 self.suggest_ref_or_into(err, expression, expected, found);
4171 self.suggest_boxing_when_appropriate(err, expression, expected, found);
4172 pointing_at_return_type
4175 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4176 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4178 /// fn foo(x: usize) -> usize { x }
4179 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4183 err: &mut DiagnosticBuilder<'tcx>,
4188 let hir = self.tcx.hir();
4189 let (def_id, sig) = match found.kind {
4190 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4191 ty::Closure(def_id, substs) => {
4192 // We don't use `closure_sig` to account for malformed closures like
4193 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4194 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4195 (def_id, match closure_sig_ty.kind {
4196 ty::FnPtr(sig) => sig,
4204 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4206 let sig = self.normalize_associated_types_in(expr.span, &sig);
4207 if self.can_coerce(sig.output(), expected) {
4208 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4209 (String::new(), Applicability::MachineApplicable)
4211 ("...".to_string(), Applicability::HasPlaceholders)
4213 let mut msg = "call this function";
4214 match hir.get_if_local(def_id) {
4215 Some(Node::Item(hir::Item {
4216 kind: ItemKind::Fn(.., body_id),
4219 Some(Node::ImplItem(hir::ImplItem {
4220 kind: hir::ImplItemKind::Method(_, body_id),
4223 Some(Node::TraitItem(hir::TraitItem {
4224 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4227 let body = hir.body(*body_id);
4228 sugg_call = body.params.iter()
4229 .map(|param| match ¶m.pat.kind {
4230 hir::PatKind::Binding(_, _, ident, None)
4231 if ident.name != kw::SelfLower => ident.to_string(),
4232 _ => "_".to_string(),
4233 }).collect::<Vec<_>>().join(", ");
4235 Some(Node::Expr(hir::Expr {
4236 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4237 span: full_closure_span,
4240 if *full_closure_span == expr.span {
4243 err.span_label(*closure_span, "closure defined here");
4244 msg = "call this closure";
4245 let body = hir.body(*body_id);
4246 sugg_call = body.params.iter()
4247 .map(|param| match ¶m.pat.kind {
4248 hir::PatKind::Binding(_, _, ident, None)
4249 if ident.name != kw::SelfLower => ident.to_string(),
4250 _ => "_".to_string(),
4251 }).collect::<Vec<_>>().join(", ");
4253 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4254 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4255 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4256 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4257 msg = "instantiate this tuple variant";
4259 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4260 msg = "instantiate this tuple struct";
4265 Some(Node::ForeignItem(hir::ForeignItem {
4266 kind: hir::ForeignItemKind::Fn(_, idents, _),
4269 Some(Node::TraitItem(hir::TraitItem {
4270 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4272 })) => sugg_call = idents.iter()
4273 .map(|ident| if ident.name != kw::SelfLower {
4277 }).collect::<Vec<_>>()
4281 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4282 err.span_suggestion(
4284 &format!("use parentheses to {}", msg),
4285 format!("{}({})", code, sugg_call),
4294 pub fn suggest_ref_or_into(
4296 err: &mut DiagnosticBuilder<'tcx>,
4301 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4302 err.span_suggestion(
4306 Applicability::MachineApplicable,
4308 } else if let (ty::FnDef(def_id, ..), true) = (
4310 self.suggest_fn_call(err, expr, expected, found),
4312 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4313 let sp = self.sess().source_map().def_span(sp);
4314 err.span_label(sp, &format!("{} defined here", found));
4316 } else if !self.check_for_cast(err, expr, found, expected) {
4317 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4321 let methods = self.get_conversion_methods(expr.span, expected, found);
4322 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4323 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4324 .filter_map(|(receiver, method)| {
4325 let method_call = format!(".{}()", method.ident);
4326 if receiver.ends_with(&method_call) {
4327 None // do not suggest code that is already there (#53348)
4329 let method_call_list = [".to_vec()", ".to_string()"];
4330 let sugg = if receiver.ends_with(".clone()")
4331 && method_call_list.contains(&method_call.as_str()) {
4332 let max_len = receiver.rfind(".").unwrap();
4333 format!("{}{}", &receiver[..max_len], method_call)
4335 format!("{}{}", receiver, method_call)
4337 Some(if is_struct_pat_shorthand_field {
4338 format!("{}: {}", receiver, sugg)
4344 if suggestions.peek().is_some() {
4345 err.span_suggestions(
4347 "try using a conversion method",
4349 Applicability::MaybeIncorrect,
4356 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4357 /// in the heap by calling `Box::new()`.
4358 fn suggest_boxing_when_appropriate(
4360 err: &mut DiagnosticBuilder<'tcx>,
4365 if self.tcx.hir().is_const_context(expr.hir_id) {
4366 // Do not suggest `Box::new` in const context.
4369 if !expected.is_box() || found.is_box() {
4372 let boxed_found = self.tcx.mk_box(found);
4373 if let (true, Ok(snippet)) = (
4374 self.can_coerce(boxed_found, expected),
4375 self.sess().source_map().span_to_snippet(expr.span),
4377 err.span_suggestion(
4379 "store this in the heap by calling `Box::new`",
4380 format!("Box::new({})", snippet),
4381 Applicability::MachineApplicable,
4383 err.note("for more on the distinction between the stack and the \
4384 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4385 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4386 https://doc.rust-lang.org/std/boxed/index.html");
4391 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4395 /// bar_that_returns_u32()
4399 /// This routine checks if the return expression in a block would make sense on its own as a
4400 /// statement and the return type has been left as default or has been specified as `()`. If so,
4401 /// it suggests adding a semicolon.
4402 fn suggest_missing_semicolon(
4404 err: &mut DiagnosticBuilder<'tcx>,
4405 expression: &'tcx hir::Expr,
4409 if expected.is_unit() {
4410 // `BlockTailExpression` only relevant if the tail expr would be
4411 // useful on its own.
4412 match expression.kind {
4413 ExprKind::Call(..) |
4414 ExprKind::MethodCall(..) |
4415 ExprKind::Loop(..) |
4416 ExprKind::Match(..) |
4417 ExprKind::Block(..) => {
4418 let sp = self.tcx.sess.source_map().next_point(cause_span);
4419 err.span_suggestion(
4421 "try adding a semicolon",
4423 Applicability::MachineApplicable);
4430 /// A possible error is to forget to add a return type that is needed:
4434 /// bar_that_returns_u32()
4438 /// This routine checks if the return type is left as default, the method is not part of an
4439 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4441 fn suggest_missing_return_type(
4443 err: &mut DiagnosticBuilder<'tcx>,
4444 fn_decl: &hir::FnDecl,
4449 // Only suggest changing the return type for methods that
4450 // haven't set a return type at all (and aren't `fn main()` or an impl).
4451 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4452 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4453 err.span_suggestion(
4455 "try adding a return type",
4456 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4457 Applicability::MachineApplicable);
4460 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4461 err.span_label(span, "possibly return type missing here?");
4464 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4465 // `fn main()` must return `()`, do not suggest changing return type
4466 err.span_label(span, "expected `()` because of default return type");
4469 // expectation was caused by something else, not the default return
4470 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4471 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4472 // Only point to return type if the expected type is the return type, as if they
4473 // are not, the expectation must have been caused by something else.
4474 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
4476 let ty = AstConv::ast_ty_to_ty(self, ty);
4477 debug!("suggest_missing_return_type: return type {:?}", ty);
4478 debug!("suggest_missing_return_type: expected type {:?}", ty);
4479 if ty.kind == expected.kind {
4480 err.span_label(sp, format!("expected `{}` because of return type",
4489 /// A possible error is to forget to add `.await` when using futures:
4492 /// async fn make_u32() -> u32 {
4496 /// fn take_u32(x: u32) {}
4498 /// async fn foo() {
4499 /// let x = make_u32();
4504 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4505 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4506 /// `.await` to the tail of the expression.
4507 fn suggest_missing_await(
4509 err: &mut DiagnosticBuilder<'tcx>,
4514 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4515 // body isn't `async`.
4516 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4517 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4518 let body = self.tcx().hir().body(body_id);
4519 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
4521 // Check for `Future` implementations by constructing a predicate to
4522 // prove: `<T as Future>::Output == U`
4523 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4524 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4525 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4526 // `<T as Future>::Output`
4527 projection_ty: ty::ProjectionTy {
4529 substs: self.tcx.mk_substs_trait(
4531 self.fresh_substs_for_item(sp, item_def_id)
4538 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4539 if self.infcx.predicate_may_hold(&obligation) {
4540 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4541 err.span_suggestion(
4543 "consider using `.await` here",
4544 format!("{}.await", code),
4545 Applicability::MaybeIncorrect,
4553 /// A common error is to add an extra semicolon:
4556 /// fn foo() -> usize {
4561 /// This routine checks if the final statement in a block is an
4562 /// expression with an explicit semicolon whose type is compatible
4563 /// with `expected_ty`. If so, it suggests removing the semicolon.
4564 fn consider_hint_about_removing_semicolon(
4566 blk: &'tcx hir::Block,
4567 expected_ty: Ty<'tcx>,
4568 err: &mut DiagnosticBuilder<'_>,
4570 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4571 err.span_suggestion(
4573 "consider removing this semicolon",
4575 Applicability::MachineApplicable,
4580 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4581 // Be helpful when the user wrote `{... expr;}` and
4582 // taking the `;` off is enough to fix the error.
4583 let last_stmt = blk.stmts.last()?;
4584 let last_expr = match last_stmt.kind {
4585 hir::StmtKind::Semi(ref e) => e,
4588 let last_expr_ty = self.node_ty(last_expr.hir_id);
4589 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4592 let original_span = original_sp(last_stmt.span, blk.span);
4593 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4596 // Instantiates the given path, which must refer to an item with the given
4597 // number of type parameters and type.
4598 pub fn instantiate_value_path(&self,
4599 segments: &[hir::PathSegment],
4600 self_ty: Option<Ty<'tcx>>,
4604 -> (Ty<'tcx>, Res) {
4606 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4615 let path_segs = match res {
4616 Res::Local(_) | Res::SelfCtor(_) => vec![],
4617 Res::Def(kind, def_id) =>
4618 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4619 _ => bug!("instantiate_value_path on {:?}", res),
4622 let mut user_self_ty = None;
4623 let mut is_alias_variant_ctor = false;
4625 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4626 if let Some(self_ty) = self_ty {
4627 let adt_def = self_ty.ty_adt_def().unwrap();
4628 user_self_ty = Some(UserSelfTy {
4629 impl_def_id: adt_def.did,
4632 is_alias_variant_ctor = true;
4635 Res::Def(DefKind::Method, def_id)
4636 | Res::Def(DefKind::AssocConst, def_id) => {
4637 let container = tcx.associated_item(def_id).container;
4638 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4640 ty::TraitContainer(trait_did) => {
4641 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4643 ty::ImplContainer(impl_def_id) => {
4644 if segments.len() == 1 {
4645 // `<T>::assoc` will end up here, and so
4646 // can `T::assoc`. It this came from an
4647 // inherent impl, we need to record the
4648 // `T` for posterity (see `UserSelfTy` for
4650 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4651 user_self_ty = Some(UserSelfTy {
4662 // Now that we have categorized what space the parameters for each
4663 // segment belong to, let's sort out the parameters that the user
4664 // provided (if any) into their appropriate spaces. We'll also report
4665 // errors if type parameters are provided in an inappropriate place.
4667 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4668 let generics_has_err = AstConv::prohibit_generics(
4669 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4670 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4677 if let Res::Local(hid) = res {
4678 let ty = self.local_ty(span, hid).decl_ty;
4679 let ty = self.normalize_associated_types_in(span, &ty);
4680 self.write_ty(hir_id, ty);
4684 if generics_has_err {
4685 // Don't try to infer type parameters when prohibited generic arguments were given.
4686 user_self_ty = None;
4689 // Now we have to compare the types that the user *actually*
4690 // provided against the types that were *expected*. If the user
4691 // did not provide any types, then we want to substitute inference
4692 // variables. If the user provided some types, we may still need
4693 // to add defaults. If the user provided *too many* types, that's
4696 let mut infer_args_for_err = FxHashSet::default();
4697 for &PathSeg(def_id, index) in &path_segs {
4698 let seg = &segments[index];
4699 let generics = tcx.generics_of(def_id);
4700 // Argument-position `impl Trait` is treated as a normal generic
4701 // parameter internally, but we don't allow users to specify the
4702 // parameter's value explicitly, so we have to do some error-
4704 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4709 false, // `is_method_call`
4711 if suppress_errors {
4712 infer_args_for_err.insert(index);
4713 self.set_tainted_by_errors(); // See issue #53251.
4717 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4718 tcx.generics_of(*def_id).has_self
4719 }).unwrap_or(false);
4721 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4722 let ty = self.impl_self_ty(span, impl_def_id).ty;
4723 let adt_def = ty.ty_adt_def();
4726 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4727 let variant = adt_def.non_enum_variant();
4728 let ctor_def_id = variant.ctor_def_id.unwrap();
4730 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4735 let mut err = tcx.sess.struct_span_err(span,
4736 "the `Self` constructor can only be used with tuple or unit structs");
4737 if let Some(adt_def) = adt_def {
4738 match adt_def.adt_kind() {
4740 err.help("did you mean to use one of the enum's variants?");
4744 err.span_suggestion(
4746 "use curly brackets",
4747 String::from("Self { /* fields */ }"),
4748 Applicability::HasPlaceholders,
4755 return (tcx.types.err, res)
4761 let def_id = res.def_id();
4763 // The things we are substituting into the type should not contain
4764 // escaping late-bound regions, and nor should the base type scheme.
4765 let ty = tcx.type_of(def_id);
4767 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4773 // Provide the generic args, and whether types should be inferred.
4775 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4778 // If we've encountered an `impl Trait`-related error, we're just
4779 // going to infer the arguments for better error messages.
4780 if !infer_args_for_err.contains(&index) {
4781 // Check whether the user has provided generic arguments.
4782 if let Some(ref data) = segments[index].args {
4783 return (Some(data), segments[index].infer_args);
4786 return (None, segments[index].infer_args);
4791 // Provide substitutions for parameters for which (valid) arguments have been provided.
4793 match (¶m.kind, arg) {
4794 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4795 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4797 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4798 self.to_ty(ty).into()
4800 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4801 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4803 _ => unreachable!(),
4806 // Provide substitutions for parameters for which arguments are inferred.
4807 |substs, param, infer_args| {
4809 GenericParamDefKind::Lifetime => {
4810 self.re_infer(Some(param), span).unwrap().into()
4812 GenericParamDefKind::Type { has_default, .. } => {
4813 if !infer_args && has_default {
4814 // If we have a default, then we it doesn't matter that we're not
4815 // inferring the type arguments: we provide the default where any
4817 let default = tcx.type_of(param.def_id);
4820 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4823 // If no type arguments were provided, we have to infer them.
4824 // This case also occurs as a result of some malformed input, e.g.
4825 // a lifetime argument being given instead of a type parameter.
4826 // Using inference instead of `Error` gives better error messages.
4827 self.var_for_def(span, param)
4830 GenericParamDefKind::Const => {
4831 // FIXME(const_generics:defaults)
4832 // No const parameters were provided, we have to infer them.
4833 self.var_for_def(span, param)
4838 assert!(!substs.has_escaping_bound_vars());
4839 assert!(!ty.has_escaping_bound_vars());
4841 // First, store the "user substs" for later.
4842 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4844 self.add_required_obligations(span, def_id, &substs);
4846 // Substitute the values for the type parameters into the type of
4847 // the referenced item.
4848 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4850 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4851 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4852 // is inherent, there is no `Self` parameter; instead, the impl needs
4853 // type parameters, which we can infer by unifying the provided `Self`
4854 // with the substituted impl type.
4855 // This also occurs for an enum variant on a type alias.
4856 let ty = tcx.type_of(impl_def_id);
4858 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4859 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4860 Ok(ok) => self.register_infer_ok_obligations(ok),
4862 self.tcx.sess.delay_span_bug(span, &format!(
4863 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4871 self.check_rustc_args_require_const(def_id, hir_id, span);
4873 debug!("instantiate_value_path: type of {:?} is {:?}",
4876 self.write_substs(hir_id, substs);
4878 (ty_substituted, res)
4881 /// Add all the obligations that are required, substituting and normalized appropriately.
4882 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
4883 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
4885 for (i, mut obligation) in traits::predicates_for_generics(
4886 traits::ObligationCause::new(
4889 traits::ItemObligation(def_id),
4893 ).into_iter().enumerate() {
4894 // This makes the error point at the bound, but we want to point at the argument
4895 if let Some(span) = spans.get(i) {
4896 obligation.cause.code = traits::BindingObligation(def_id, *span);
4898 self.register_predicate(obligation);
4902 fn check_rustc_args_require_const(&self,
4906 // We're only interested in functions tagged with
4907 // #[rustc_args_required_const], so ignore anything that's not.
4908 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4912 // If our calling expression is indeed the function itself, we're good!
4913 // If not, generate an error that this can only be called directly.
4914 if let Node::Expr(expr) = self.tcx.hir().get(
4915 self.tcx.hir().get_parent_node(hir_id))
4917 if let ExprKind::Call(ref callee, ..) = expr.kind {
4918 if callee.hir_id == hir_id {
4924 self.tcx.sess.span_err(span, "this function can only be invoked \
4925 directly, not through a function pointer");
4928 // Resolves `typ` by a single level if `typ` is a type variable.
4929 // If no resolution is possible, then an error is reported.
4930 // Numeric inference variables may be left unresolved.
4931 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4932 let ty = self.resolve_type_vars_with_obligations(ty);
4933 if !ty.is_ty_var() {
4936 if !self.is_tainted_by_errors() {
4937 self.need_type_info_err((**self).body_id, sp, ty)
4938 .note("type must be known at this point")
4941 self.demand_suptype(sp, self.tcx.types.err, ty);
4946 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4949 ctxt: BreakableCtxt<'tcx>,
4951 ) -> (BreakableCtxt<'tcx>, R) {
4954 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4955 index = enclosing_breakables.stack.len();
4956 enclosing_breakables.by_id.insert(id, index);
4957 enclosing_breakables.stack.push(ctxt);
4961 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4962 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4963 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4964 enclosing_breakables.stack.pop().expect("missing breakable context")
4969 /// Instantiate a QueryResponse in a probe context, without a
4970 /// good ObligationCause.
4971 fn probe_instantiate_query_response(
4974 original_values: &OriginalQueryValues<'tcx>,
4975 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4976 ) -> InferResult<'tcx, Ty<'tcx>>
4978 self.instantiate_query_response_and_region_obligations(
4979 &traits::ObligationCause::misc(span, self.body_id),
4985 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4986 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4987 let mut contained_in_place = false;
4989 while let hir::Node::Expr(parent_expr) =
4990 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4992 match &parent_expr.kind {
4993 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4994 if lhs.hir_id == expr_id {
4995 contained_in_place = true;
5001 expr_id = parent_expr.hir_id;
5008 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5009 let own_counts = generics.own_counts();
5011 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5017 if own_counts.types == 0 {
5021 // Make a vector of booleans initially `false`; set to `true` when used.
5022 let mut types_used = vec![false; own_counts.types];
5024 for leaf_ty in ty.walk() {
5025 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5026 debug!("found use of ty param num {}", index);
5027 types_used[index as usize - own_counts.lifetimes] = true;
5028 } else if let ty::Error = leaf_ty.kind {
5029 // If there is already another error, do not emit
5030 // an error for not using a type parameter.
5031 assert!(tcx.sess.has_errors());
5036 let types = generics.params.iter().filter(|param| match param.kind {
5037 ty::GenericParamDefKind::Type { .. } => true,
5040 for (&used, param) in types_used.iter().zip(types) {
5042 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5043 let span = tcx.hir().span(id);
5044 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5045 .span_label(span, "unused type parameter")
5051 fn fatally_break_rust(sess: &Session) {
5052 let handler = sess.diagnostic();
5053 handler.span_bug_no_panic(
5055 "It looks like you're trying to break rust; would you like some ICE?",
5057 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5058 handler.note_without_error(
5059 "we would appreciate a joke overview: \
5060 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5062 handler.note_without_error(&format!("rustc {} running on {}",
5063 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5064 crate::session::config::host_triple(),
5068 fn potentially_plural_count(count: usize, word: &str) -> String {
5069 format!("{} {}{}", count, word, pluralise!(count))