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.node {
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 // Add formal parameters.
1136 for (param_ty, param) in fn_sig.inputs().iter().zip(&body.params) {
1137 // Check the pattern.
1138 fcx.check_pat_top(¶m.pat, param_ty, None);
1140 // Check that argument is Sized.
1141 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1142 // for simple cases like `fn foo(x: Trait)`,
1143 // where we would error once on the parameter as a whole, and once on the binding `x`.
1144 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1145 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1148 fcx.write_ty(param.hir_id, param_ty);
1151 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1153 fcx.check_return_expr(&body.value);
1155 // We insert the deferred_generator_interiors entry after visiting the body.
1156 // This ensures that all nested generators appear before the entry of this generator.
1157 // resolve_generator_interiors relies on this property.
1158 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1159 let interior = fcx.next_ty_var(TypeVariableOrigin {
1160 kind: TypeVariableOriginKind::MiscVariable,
1163 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1164 Some(GeneratorTypes {
1165 yield_ty: fcx.yield_ty.unwrap(),
1167 movability: can_be_generator.unwrap(),
1173 // Finalize the return check by taking the LUB of the return types
1174 // we saw and assigning it to the expected return type. This isn't
1175 // really expected to fail, since the coercions would have failed
1176 // earlier when trying to find a LUB.
1178 // However, the behavior around `!` is sort of complex. In the
1179 // event that the `actual_return_ty` comes back as `!`, that
1180 // indicates that the fn either does not return or "returns" only
1181 // values of type `!`. In this case, if there is an expected
1182 // return type that is *not* `!`, that should be ok. But if the
1183 // return type is being inferred, we want to "fallback" to `!`:
1185 // let x = move || panic!();
1187 // To allow for that, I am creating a type variable with diverging
1188 // fallback. This was deemed ever so slightly better than unifying
1189 // the return value with `!` because it allows for the caller to
1190 // make more assumptions about the return type (e.g., they could do
1192 // let y: Option<u32> = Some(x());
1194 // which would then cause this return type to become `u32`, not
1196 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1197 let mut actual_return_ty = coercion.complete(&fcx);
1198 if actual_return_ty.is_never() {
1199 actual_return_ty = fcx.next_diverging_ty_var(
1200 TypeVariableOrigin {
1201 kind: TypeVariableOriginKind::DivergingFn,
1206 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1208 // Check that the main return type implements the termination trait.
1209 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1210 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1211 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1212 if main_id == fn_id {
1213 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1214 let trait_ref = ty::TraitRef::new(term_id, substs);
1215 let return_ty_span = decl.output.span();
1216 let cause = traits::ObligationCause::new(
1217 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1219 inherited.register_predicate(
1220 traits::Obligation::new(
1221 cause, param_env, trait_ref.to_predicate()));
1226 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1227 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1228 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1229 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1230 // at this point we don't care if there are duplicate handlers or if the handler has
1231 // the wrong signature as this value we'll be used when writing metadata and that
1232 // only happens if compilation succeeded
1233 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1235 if declared_ret_ty.kind != ty::Never {
1236 fcx.tcx.sess.span_err(
1238 "return type should be `!`",
1242 let inputs = fn_sig.inputs();
1243 let span = fcx.tcx.hir().span(fn_id);
1244 if inputs.len() == 1 {
1245 let arg_is_panic_info = match inputs[0].kind {
1246 ty::Ref(region, ty, mutbl) => match ty.kind {
1247 ty::Adt(ref adt, _) => {
1248 adt.did == panic_info_did &&
1249 mutbl == hir::Mutability::MutImmutable &&
1250 *region != RegionKind::ReStatic
1257 if !arg_is_panic_info {
1258 fcx.tcx.sess.span_err(
1259 decl.inputs[0].span,
1260 "argument should be `&PanicInfo`",
1264 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1265 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1266 if !generics.params.is_empty() {
1267 fcx.tcx.sess.span_err(
1269 "should have no type parameters",
1275 let span = fcx.tcx.sess.source_map().def_span(span);
1276 fcx.tcx.sess.span_err(span, "function should have one argument");
1279 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1284 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1285 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1286 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1287 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1288 if declared_ret_ty.kind != ty::Never {
1289 fcx.tcx.sess.span_err(
1291 "return type should be `!`",
1295 let inputs = fn_sig.inputs();
1296 let span = fcx.tcx.hir().span(fn_id);
1297 if inputs.len() == 1 {
1298 let arg_is_alloc_layout = match inputs[0].kind {
1299 ty::Adt(ref adt, _) => {
1300 adt.did == alloc_layout_did
1305 if !arg_is_alloc_layout {
1306 fcx.tcx.sess.span_err(
1307 decl.inputs[0].span,
1308 "argument should be `Layout`",
1312 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1313 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1314 if !generics.params.is_empty() {
1315 fcx.tcx.sess.span_err(
1317 "`#[alloc_error_handler]` function should have no type \
1324 let span = fcx.tcx.sess.source_map().def_span(span);
1325 fcx.tcx.sess.span_err(span, "function should have one argument");
1328 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1336 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1337 let def_id = tcx.hir().local_def_id(id);
1338 let def = tcx.adt_def(def_id);
1339 def.destructor(tcx); // force the destructor to be evaluated
1340 check_representable(tcx, span, def_id);
1342 if def.repr.simd() {
1343 check_simd(tcx, span, def_id);
1346 check_transparent(tcx, span, def_id);
1347 check_packed(tcx, span, def_id);
1350 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1351 let def_id = tcx.hir().local_def_id(id);
1352 let def = tcx.adt_def(def_id);
1353 def.destructor(tcx); // force the destructor to be evaluated
1354 check_representable(tcx, span, def_id);
1355 check_transparent(tcx, span, def_id);
1356 check_packed(tcx, span, def_id);
1359 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1360 /// projections that would result in "inheriting lifetimes".
1361 fn check_opaque<'tcx>(
1364 substs: SubstsRef<'tcx>,
1366 origin: &hir::OpaqueTyOrigin,
1368 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1369 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1372 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1373 /// in "inheriting lifetimes".
1374 fn check_opaque_for_inheriting_lifetimes(
1379 let item = tcx.hir().expect_item(
1380 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1381 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1382 def_id, span, item);
1385 struct ProhibitOpaqueVisitor<'tcx> {
1386 opaque_identity_ty: Ty<'tcx>,
1387 generics: &'tcx ty::Generics,
1390 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1391 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1392 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1393 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1396 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1397 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1398 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1399 return *index < self.generics.parent_count as u32;
1402 r.super_visit_with(self)
1406 let prohibit_opaque = match item.node {
1407 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1408 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1409 let mut visitor = ProhibitOpaqueVisitor {
1410 opaque_identity_ty: tcx.mk_opaque(
1411 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1412 generics: tcx.generics_of(def_id),
1414 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1416 tcx.predicates_of(def_id).predicates.iter().any(
1417 |(predicate, _)| predicate.visit_with(&mut visitor))
1422 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1423 if prohibit_opaque {
1424 let is_async = match item.node {
1425 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1426 hir::OpaqueTyOrigin::AsyncFn => true,
1429 _ => unreachable!(),
1432 tcx.sess.span_err(span, &format!(
1433 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1435 if is_async { "async fn" } else { "impl Trait" },
1440 /// Checks that an opaque type does not contain cycles.
1441 fn check_opaque_for_cycles<'tcx>(
1444 substs: SubstsRef<'tcx>,
1446 origin: &hir::OpaqueTyOrigin,
1448 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1449 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1451 tcx.sess, span, E0733,
1452 "recursion in an `async fn` requires boxing",
1454 .span_label(span, "recursive `async fn`")
1455 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1458 let mut err = struct_span_err!(
1459 tcx.sess, span, E0720,
1460 "opaque type expands to a recursive type",
1462 err.span_label(span, "expands to a recursive type");
1463 if let ty::Opaque(..) = partially_expanded_type.kind {
1464 err.note("type resolves to itself");
1466 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1473 // Forbid defining intrinsics in Rust code,
1474 // as they must always be defined by the compiler.
1475 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1476 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1477 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1481 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1483 "check_item_type(it.hir_id={}, it.name={})",
1485 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1487 let _indenter = indenter();
1489 // Consts can play a role in type-checking, so they are included here.
1490 hir::ItemKind::Static(..) => {
1491 let def_id = tcx.hir().local_def_id(it.hir_id);
1492 tcx.typeck_tables_of(def_id);
1493 maybe_check_static_with_link_section(tcx, def_id, it.span);
1495 hir::ItemKind::Const(..) => {
1496 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1498 hir::ItemKind::Enum(ref enum_definition, _) => {
1499 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1501 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1502 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1503 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1504 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1505 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1506 check_impl_items_against_trait(
1513 let trait_def_id = impl_trait_ref.def_id;
1514 check_on_unimplemented(tcx, trait_def_id, it);
1517 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1518 let def_id = tcx.hir().local_def_id(it.hir_id);
1519 check_on_unimplemented(tcx, def_id, it);
1521 for item in items.iter() {
1522 let item = tcx.hir().trait_item(item.id);
1523 if let hir::TraitItemKind::Method(sig, _) = &item.node {
1524 let abi = sig.header.abi;
1525 fn_maybe_err(tcx, item.ident.span, abi);
1529 hir::ItemKind::Struct(..) => {
1530 check_struct(tcx, it.hir_id, it.span);
1532 hir::ItemKind::Union(..) => {
1533 check_union(tcx, it.hir_id, it.span);
1535 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1536 let def_id = tcx.hir().local_def_id(it.hir_id);
1538 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1539 check_opaque(tcx, def_id, substs, it.span, &origin);
1541 hir::ItemKind::TyAlias(..) => {
1542 let def_id = tcx.hir().local_def_id(it.hir_id);
1543 let pty_ty = tcx.type_of(def_id);
1544 let generics = tcx.generics_of(def_id);
1545 check_bounds_are_used(tcx, &generics, pty_ty);
1547 hir::ItemKind::ForeignMod(ref m) => {
1548 check_abi(tcx, it.span, m.abi);
1550 if m.abi == Abi::RustIntrinsic {
1551 for item in &m.items {
1552 intrinsic::check_intrinsic_type(tcx, item);
1554 } else if m.abi == Abi::PlatformIntrinsic {
1555 for item in &m.items {
1556 intrinsic::check_platform_intrinsic_type(tcx, item);
1559 for item in &m.items {
1560 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1561 let own_counts = generics.own_counts();
1562 if generics.params.len() - own_counts.lifetimes != 0 {
1563 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1564 (_, 0) => ("type", "types", Some("u32")),
1565 // We don't specify an example value, because we can't generate
1566 // a valid value for any type.
1567 (0, _) => ("const", "consts", None),
1568 _ => ("type or const", "types or consts", None),
1574 "foreign items may not have {} parameters",
1578 &format!("can't have {} parameters", kinds),
1580 // FIXME: once we start storing spans for type arguments, turn this
1581 // into a suggestion.
1583 "replace the {} parameters with concrete {}{}",
1586 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1591 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1592 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1597 _ => { /* nothing to do */ }
1601 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1602 // Only restricted on wasm32 target for now
1603 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1607 // If `#[link_section]` is missing, then nothing to verify
1608 let attrs = tcx.codegen_fn_attrs(id);
1609 if attrs.link_section.is_none() {
1613 // For the wasm32 target statics with `#[link_section]` are placed into custom
1614 // sections of the final output file, but this isn't link custom sections of
1615 // other executable formats. Namely we can only embed a list of bytes,
1616 // nothing with pointers to anything else or relocations. If any relocation
1617 // show up, reject them here.
1618 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1619 // the consumer's responsibility to ensure all bytes that have been read
1620 // have defined values.
1621 let instance = ty::Instance::mono(tcx, id);
1622 let cid = GlobalId {
1626 let param_env = ty::ParamEnv::reveal_all();
1627 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1628 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1631 bug!("Matching on non-ByRef static")
1633 if alloc.relocations().len() != 0 {
1634 let msg = "statics with a custom `#[link_section]` must be a \
1635 simple list of bytes on the wasm target with no \
1636 extra levels of indirection such as references";
1637 tcx.sess.span_err(span, msg);
1642 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1643 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1644 // an error would be reported if this fails.
1645 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1648 fn report_forbidden_specialization(
1650 impl_item: &hir::ImplItem,
1653 let mut err = struct_span_err!(
1654 tcx.sess, impl_item.span, E0520,
1655 "`{}` specializes an item from a parent `impl`, but \
1656 that item is not marked `default`",
1658 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1661 match tcx.span_of_impl(parent_impl) {
1663 err.span_label(span, "parent `impl` is here");
1664 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1668 err.note(&format!("parent implementation is in crate `{}`", cname));
1675 fn check_specialization_validity<'tcx>(
1677 trait_def: &ty::TraitDef,
1678 trait_item: &ty::AssocItem,
1680 impl_item: &hir::ImplItem,
1682 let ancestors = trait_def.ancestors(tcx, impl_id);
1684 let kind = match impl_item.node {
1685 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1686 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1687 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1688 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1691 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1692 .map(|node_item| node_item.map(|parent| parent.defaultness));
1694 if let Some(parent) = parent {
1695 if tcx.impl_item_is_final(&parent) {
1696 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1702 fn check_impl_items_against_trait<'tcx>(
1706 impl_trait_ref: ty::TraitRef<'tcx>,
1707 impl_item_refs: &[hir::ImplItemRef],
1709 let impl_span = tcx.sess.source_map().def_span(impl_span);
1711 // If the trait reference itself is erroneous (so the compilation is going
1712 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1713 // isn't populated for such impls.
1714 if impl_trait_ref.references_error() { return; }
1716 // Locate trait definition and items
1717 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1718 let mut overridden_associated_type = None;
1720 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1722 // Check existing impl methods to see if they are both present in trait
1723 // and compatible with trait signature
1724 for impl_item in impl_items() {
1725 let ty_impl_item = tcx.associated_item(
1726 tcx.hir().local_def_id(impl_item.hir_id));
1727 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1728 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1729 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1731 // Not compatible, but needed for the error message
1732 tcx.associated_items(impl_trait_ref.def_id)
1733 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1736 // Check that impl definition matches trait definition
1737 if let Some(ty_trait_item) = ty_trait_item {
1738 match impl_item.node {
1739 hir::ImplItemKind::Const(..) => {
1740 // Find associated const definition.
1741 if ty_trait_item.kind == ty::AssocKind::Const {
1742 compare_const_impl(tcx,
1748 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1749 "item `{}` is an associated const, \
1750 which doesn't match its trait `{}`",
1753 err.span_label(impl_item.span, "does not match trait");
1754 // We can only get the spans from local trait definition
1755 // Same for E0324 and E0325
1756 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1757 err.span_label(trait_span, "item in trait");
1762 hir::ImplItemKind::Method(..) => {
1763 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1764 if ty_trait_item.kind == ty::AssocKind::Method {
1765 compare_impl_method(tcx,
1772 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1773 "item `{}` is an associated method, \
1774 which doesn't match its trait `{}`",
1777 err.span_label(impl_item.span, "does not match trait");
1778 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1779 err.span_label(trait_span, "item in trait");
1784 hir::ImplItemKind::OpaqueTy(..) |
1785 hir::ImplItemKind::TyAlias(_) => {
1786 if ty_trait_item.kind == ty::AssocKind::Type {
1787 if ty_trait_item.defaultness.has_value() {
1788 overridden_associated_type = Some(impl_item);
1791 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1792 "item `{}` is an associated type, \
1793 which doesn't match its trait `{}`",
1796 err.span_label(impl_item.span, "does not match trait");
1797 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1798 err.span_label(trait_span, "item in trait");
1805 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1809 // Check for missing items from trait
1810 let mut missing_items = Vec::new();
1811 let mut invalidated_items = Vec::new();
1812 let associated_type_overridden = overridden_associated_type.is_some();
1813 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1814 let is_implemented = trait_def.ancestors(tcx, impl_id)
1815 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1817 .map(|node_item| !node_item.node.is_from_trait())
1820 if !is_implemented && !tcx.impl_is_default(impl_id) {
1821 if !trait_item.defaultness.has_value() {
1822 missing_items.push(trait_item);
1823 } else if associated_type_overridden {
1824 invalidated_items.push(trait_item.ident);
1829 if !missing_items.is_empty() {
1830 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1831 "not all trait items implemented, missing: `{}`",
1832 missing_items.iter()
1833 .map(|trait_item| trait_item.ident.to_string())
1834 .collect::<Vec<_>>().join("`, `"));
1835 err.span_label(impl_span, format!("missing `{}` in implementation",
1836 missing_items.iter()
1837 .map(|trait_item| trait_item.ident.to_string())
1838 .collect::<Vec<_>>().join("`, `")));
1839 for trait_item in missing_items {
1840 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1841 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1843 err.note_trait_signature(trait_item.ident.to_string(),
1844 trait_item.signature(tcx));
1850 if !invalidated_items.is_empty() {
1851 let invalidator = overridden_associated_type.unwrap();
1852 span_err!(tcx.sess, invalidator.span, E0399,
1853 "the following trait items need to be reimplemented \
1854 as `{}` was overridden: `{}`",
1856 invalidated_items.iter()
1857 .map(|name| name.to_string())
1858 .collect::<Vec<_>>().join("`, `"))
1862 /// Checks whether a type can be represented in memory. In particular, it
1863 /// identifies types that contain themselves without indirection through a
1864 /// pointer, which would mean their size is unbounded.
1865 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1866 let rty = tcx.type_of(item_def_id);
1868 // Check that it is possible to represent this type. This call identifies
1869 // (1) types that contain themselves and (2) types that contain a different
1870 // recursive type. It is only necessary to throw an error on those that
1871 // contain themselves. For case 2, there must be an inner type that will be
1872 // caught by case 1.
1873 match rty.is_representable(tcx, sp) {
1874 Representability::SelfRecursive(spans) => {
1875 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1877 err.span_label(span, "recursive without indirection");
1882 Representability::Representable | Representability::ContainsRecursive => (),
1887 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1888 let t = tcx.type_of(def_id);
1889 if let ty::Adt(def, substs) = t.kind {
1890 if def.is_struct() {
1891 let fields = &def.non_enum_variant().fields;
1892 if fields.is_empty() {
1893 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1896 let e = fields[0].ty(tcx, substs);
1897 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1898 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1899 .span_label(sp, "SIMD elements must have the same type")
1904 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1905 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1907 span_err!(tcx.sess, sp, E0077,
1908 "SIMD vector element type should be machine type");
1916 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1917 let repr = tcx.adt_def(def_id).repr;
1919 for attr in tcx.get_attrs(def_id).iter() {
1920 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1921 if let attr::ReprPacked(pack) = r {
1922 if let Some(repr_pack) = repr.pack {
1923 if pack as u64 != repr_pack.bytes() {
1925 tcx.sess, sp, E0634,
1926 "type has conflicting packed representation hints"
1933 if repr.align.is_some() {
1934 struct_span_err!(tcx.sess, sp, E0587,
1935 "type has conflicting packed and align representation hints").emit();
1937 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1938 struct_span_err!(tcx.sess, sp, E0588,
1939 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1944 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1945 let t = tcx.type_of(def_id);
1946 if stack.contains(&def_id) {
1947 debug!("check_packed_inner: {:?} is recursive", t);
1950 if let ty::Adt(def, substs) = t.kind {
1951 if def.is_struct() || def.is_union() {
1952 if tcx.adt_def(def.did).repr.align.is_some() {
1955 // push struct def_id before checking fields
1957 for field in &def.non_enum_variant().fields {
1958 let f = field.ty(tcx, substs);
1959 if let ty::Adt(def, _) = f.kind {
1960 if check_packed_inner(tcx, def.did, stack) {
1965 // only need to pop if not early out
1972 /// Emit an error when encountering more or less than one variant in a transparent enum.
1973 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1974 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1975 tcx.hir().span_if_local(variant.def_id).unwrap()
1978 "needs exactly one variant, but has {}",
1981 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1982 err.span_label(sp, &msg);
1983 if let &[ref start @ .., ref end] = &variant_spans[..] {
1984 for variant_span in start {
1985 err.span_label(*variant_span, "");
1987 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1992 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1994 fn bad_non_zero_sized_fields<'tcx>(
1996 adt: &'tcx ty::AdtDef,
1998 field_spans: impl Iterator<Item = Span>,
2001 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2002 let mut err = struct_span_err!(
2006 "{}transparent {} {}",
2007 if adt.is_enum() { "the variant of a " } else { "" },
2011 err.span_label(sp, &msg);
2012 for sp in field_spans {
2013 err.span_label(sp, "this field is non-zero-sized");
2018 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2019 let adt = tcx.adt_def(def_id);
2020 if !adt.repr.transparent() {
2023 let sp = tcx.sess.source_map().def_span(sp);
2026 if !tcx.features().transparent_enums {
2028 &tcx.sess.parse_sess,
2029 sym::transparent_enums,
2031 GateIssue::Language,
2032 "transparent enums are unstable",
2035 if adt.variants.len() != 1 {
2036 bad_variant_count(tcx, adt, sp, def_id);
2037 if adt.variants.is_empty() {
2038 // Don't bother checking the fields. No variants (and thus no fields) exist.
2044 if adt.is_union() && !tcx.features().transparent_unions {
2045 emit_feature_err(&tcx.sess.parse_sess,
2046 sym::transparent_unions,
2048 GateIssue::Language,
2049 "transparent unions are unstable");
2052 // For each field, figure out if it's known to be a ZST and align(1)
2053 let field_infos = adt.all_fields().map(|field| {
2054 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2055 let param_env = tcx.param_env(field.did);
2056 let layout = tcx.layout_of(param_env.and(ty));
2057 // We are currently checking the type this field came from, so it must be local
2058 let span = tcx.hir().span_if_local(field.did).unwrap();
2059 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2060 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2064 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2069 let non_zst_count = non_zst_fields.clone().count();
2070 if non_zst_count != 1 {
2071 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2073 for (span, zst, align1) in field_infos {
2079 "zero-sized field in transparent {} has alignment larger than 1",
2081 ).span_label(span, "has alignment larger than 1").emit();
2086 #[allow(trivial_numeric_casts)]
2087 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
2088 let def_id = tcx.hir().local_def_id(id);
2089 let def = tcx.adt_def(def_id);
2090 def.destructor(tcx); // force the destructor to be evaluated
2093 let attributes = tcx.get_attrs(def_id);
2094 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2096 tcx.sess, attr.span, E0084,
2097 "unsupported representation for zero-variant enum")
2098 .span_label(sp, "zero-variant enum")
2103 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2104 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2105 if !tcx.features().repr128 {
2106 emit_feature_err(&tcx.sess.parse_sess,
2109 GateIssue::Language,
2110 "repr with 128-bit type is unstable");
2115 if let Some(ref e) = v.disr_expr {
2116 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2120 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2122 |var: &hir::Variant| match var.data {
2123 hir::VariantData::Unit(..) => true,
2127 let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
2128 let has_non_units = vs.iter().any(|var| !is_unit(var));
2129 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2130 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2132 if disr_non_unit || (disr_units && has_non_units) {
2133 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2134 "`#[repr(inttype)]` must be specified");
2139 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2140 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2141 // Check for duplicate discriminant values
2142 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2143 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2144 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2145 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2146 let i_span = match variant_i.disr_expr {
2147 Some(ref expr) => tcx.hir().span(expr.hir_id),
2148 None => tcx.hir().span(variant_i_hir_id)
2150 let span = match v.disr_expr {
2151 Some(ref expr) => tcx.hir().span(expr.hir_id),
2154 struct_span_err!(tcx.sess, span, E0081,
2155 "discriminant value `{}` already exists", disr_vals[i])
2156 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2157 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2160 disr_vals.push(discr);
2163 check_representable(tcx, sp, def_id);
2164 check_transparent(tcx, sp, def_id);
2167 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2168 span_err!(tcx.sess, span, E0533,
2169 "expected unit struct/variant or constant, found {} `{}`",
2171 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2174 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2175 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2179 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2180 -> &'tcx ty::GenericPredicates<'tcx>
2183 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2184 let item_id = tcx.hir().ty_param_owner(hir_id);
2185 let item_def_id = tcx.hir().local_def_id(item_id);
2186 let generics = tcx.generics_of(item_def_id);
2187 let index = generics.param_def_id_to_index[&def_id];
2188 tcx.arena.alloc(ty::GenericPredicates {
2190 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2192 ty::Predicate::Trait(ref data)
2193 if data.skip_binder().self_ty().is_param(index) => {
2194 // HACK(eddyb) should get the original `Span`.
2195 let span = tcx.def_span(def_id);
2196 Some((predicate, span))
2206 def: Option<&ty::GenericParamDef>,
2208 ) -> Option<ty::Region<'tcx>> {
2210 Some(def) => infer::EarlyBoundRegion(span, def.name),
2211 None => infer::MiscVariable(span)
2213 Some(self.next_region_var(v))
2216 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2217 if let Some(param) = param {
2218 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2223 self.next_ty_var(TypeVariableOrigin {
2224 kind: TypeVariableOriginKind::TypeInference,
2233 param: Option<&ty::GenericParamDef>,
2235 ) -> &'tcx Const<'tcx> {
2236 if let Some(param) = param {
2237 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2242 self.next_const_var(ty, ConstVariableOrigin {
2243 kind: ConstVariableOriginKind::ConstInference,
2249 fn projected_ty_from_poly_trait_ref(&self,
2252 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2255 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2257 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2261 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2264 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2265 if ty.has_escaping_bound_vars() {
2266 ty // FIXME: normalization and escaping regions
2268 self.normalize_associated_types_in(span, &ty)
2272 fn set_tainted_by_errors(&self) {
2273 self.infcx.set_tainted_by_errors()
2276 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2277 self.write_ty(hir_id, ty)
2281 /// Controls whether the arguments are tupled. This is used for the call
2284 /// Tupling means that all call-side arguments are packed into a tuple and
2285 /// passed as a single parameter. For example, if tupling is enabled, this
2288 /// fn f(x: (isize, isize))
2290 /// Can be called as:
2297 #[derive(Clone, Eq, PartialEq)]
2298 enum TupleArgumentsFlag {
2303 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2305 inh: &'a Inherited<'a, 'tcx>,
2306 param_env: ty::ParamEnv<'tcx>,
2307 body_id: hir::HirId,
2308 ) -> FnCtxt<'a, 'tcx> {
2312 err_count_on_creation: inh.tcx.sess.err_count(),
2314 ret_coercion_span: RefCell::new(None),
2316 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2317 hir::CRATE_HIR_ID)),
2318 diverges: Cell::new(Diverges::Maybe),
2319 has_errors: Cell::new(false),
2320 enclosing_breakables: RefCell::new(EnclosingBreakables {
2322 by_id: Default::default(),
2328 pub fn sess(&self) -> &Session {
2332 pub fn errors_reported_since_creation(&self) -> bool {
2333 self.tcx.sess.err_count() > self.err_count_on_creation
2336 /// Produces warning on the given node, if the current point in the
2337 /// function is unreachable, and there hasn't been another warning.
2338 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2339 // FIXME: Combine these two 'if' expressions into one once
2340 // let chains are implemented
2341 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2342 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2343 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2344 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2345 if !span.is_desugaring(DesugaringKind::CondTemporary) &&
2346 !span.is_desugaring(DesugaringKind::Async)
2348 self.diverges.set(Diverges::WarnedAlways);
2350 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2352 let msg = format!("unreachable {}", kind);
2353 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2354 .span_label(span, &msg)
2357 custom_note.unwrap_or("any code following this expression is unreachable"),
2366 code: ObligationCauseCode<'tcx>)
2367 -> ObligationCause<'tcx> {
2368 ObligationCause::new(span, self.body_id, code)
2371 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2372 self.cause(span, ObligationCauseCode::MiscObligation)
2375 /// Resolves type variables in `ty` if possible. Unlike the infcx
2376 /// version (resolve_vars_if_possible), this version will
2377 /// also select obligations if it seems useful, in an effort
2378 /// to get more type information.
2379 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2380 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2382 // No Infer()? Nothing needs doing.
2383 if !ty.has_infer_types() {
2384 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2388 // If `ty` is a type variable, see whether we already know what it is.
2389 ty = self.resolve_vars_if_possible(&ty);
2390 if !ty.has_infer_types() {
2391 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2395 // If not, try resolving pending obligations as much as
2396 // possible. This can help substantially when there are
2397 // indirect dependencies that don't seem worth tracking
2399 self.select_obligations_where_possible(false, |_| {});
2400 ty = self.resolve_vars_if_possible(&ty);
2402 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2406 fn record_deferred_call_resolution(
2408 closure_def_id: DefId,
2409 r: DeferredCallResolution<'tcx>,
2411 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2412 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2415 fn remove_deferred_call_resolutions(
2417 closure_def_id: DefId,
2418 ) -> Vec<DeferredCallResolution<'tcx>> {
2419 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2420 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2423 pub fn tag(&self) -> String {
2424 format!("{:p}", self)
2427 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2428 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2429 span_bug!(span, "no type for local variable {}",
2430 self.tcx.hir().node_to_string(nid))
2435 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2436 debug!("write_ty({:?}, {:?}) in fcx {}",
2437 id, self.resolve_vars_if_possible(&ty), self.tag());
2438 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2440 if ty.references_error() {
2441 self.has_errors.set(true);
2442 self.set_tainted_by_errors();
2446 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2447 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2450 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2451 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2454 pub fn write_method_call(&self,
2456 method: MethodCallee<'tcx>) {
2457 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2458 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2459 self.write_substs(hir_id, method.substs);
2461 // When the method is confirmed, the `method.substs` includes
2462 // parameters from not just the method, but also the impl of
2463 // the method -- in particular, the `Self` type will be fully
2464 // resolved. However, those are not something that the "user
2465 // specified" -- i.e., those types come from the inferred type
2466 // of the receiver, not something the user wrote. So when we
2467 // create the user-substs, we want to replace those earlier
2468 // types with just the types that the user actually wrote --
2469 // that is, those that appear on the *method itself*.
2471 // As an example, if the user wrote something like
2472 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2473 // type of `foo` (possibly adjusted), but we don't want to
2474 // include that. We want just the `[_, u32]` part.
2475 if !method.substs.is_noop() {
2476 let method_generics = self.tcx.generics_of(method.def_id);
2477 if !method_generics.params.is_empty() {
2478 let user_type_annotation = self.infcx.probe(|_| {
2479 let user_substs = UserSubsts {
2480 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2481 let i = param.index as usize;
2482 if i < method_generics.parent_count {
2483 self.infcx.var_for_def(DUMMY_SP, param)
2488 user_self_ty: None, // not relevant here
2491 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2497 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2498 self.write_user_type_annotation(hir_id, user_type_annotation);
2503 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2504 if !substs.is_noop() {
2505 debug!("write_substs({:?}, {:?}) in fcx {}",
2510 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2514 /// Given the substs that we just converted from the HIR, try to
2515 /// canonicalize them and store them as user-given substitutions
2516 /// (i.e., substitutions that must be respected by the NLL check).
2518 /// This should be invoked **before any unifications have
2519 /// occurred**, so that annotations like `Vec<_>` are preserved
2521 pub fn write_user_type_annotation_from_substs(
2525 substs: SubstsRef<'tcx>,
2526 user_self_ty: Option<UserSelfTy<'tcx>>,
2529 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2530 user_self_ty={:?} in fcx {}",
2531 hir_id, def_id, substs, user_self_ty, self.tag(),
2534 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2535 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2536 &UserType::TypeOf(def_id, UserSubsts {
2541 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2542 self.write_user_type_annotation(hir_id, canonicalized);
2546 pub fn write_user_type_annotation(
2549 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2552 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2553 hir_id, canonical_user_type_annotation, self.tag(),
2556 if !canonical_user_type_annotation.is_identity() {
2557 self.tables.borrow_mut().user_provided_types_mut().insert(
2558 hir_id, canonical_user_type_annotation
2561 debug!("write_user_type_annotation: skipping identity substs");
2565 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2566 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2572 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2573 Entry::Vacant(entry) => { entry.insert(adj); },
2574 Entry::Occupied(mut entry) => {
2575 debug!(" - composing on top of {:?}", entry.get());
2576 match (&entry.get()[..], &adj[..]) {
2577 // Applying any adjustment on top of a NeverToAny
2578 // is a valid NeverToAny adjustment, because it can't
2580 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2582 Adjustment { kind: Adjust::Deref(_), .. },
2583 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2585 Adjustment { kind: Adjust::Deref(_), .. },
2586 .. // Any following adjustments are allowed.
2588 // A reborrow has no effect before a dereference.
2590 // FIXME: currently we never try to compose autoderefs
2591 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2593 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2594 expr, entry.get(), adj)
2596 *entry.get_mut() = adj;
2601 /// Basically whenever we are converting from a type scheme into
2602 /// the fn body space, we always want to normalize associated
2603 /// types as well. This function combines the two.
2604 fn instantiate_type_scheme<T>(&self,
2606 substs: SubstsRef<'tcx>,
2609 where T : TypeFoldable<'tcx>
2611 let value = value.subst(self.tcx, substs);
2612 let result = self.normalize_associated_types_in(span, &value);
2613 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2620 /// As `instantiate_type_scheme`, but for the bounds found in a
2621 /// generic type scheme.
2622 fn instantiate_bounds(
2626 substs: SubstsRef<'tcx>,
2627 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
2628 let bounds = self.tcx.predicates_of(def_id);
2629 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
2630 let result = bounds.instantiate(self.tcx, substs);
2631 let result = self.normalize_associated_types_in(span, &result);
2633 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
2642 /// Replaces the opaque types from the given value with type variables,
2643 /// and records the `OpaqueTypeMap` for later use during writeback. See
2644 /// `InferCtxt::instantiate_opaque_types` for more details.
2645 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2647 parent_id: hir::HirId,
2651 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2652 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2656 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2657 self.instantiate_opaque_types(
2666 let mut opaque_types = self.opaque_types.borrow_mut();
2667 for (ty, decl) in opaque_type_map {
2668 let old_value = opaque_types.insert(ty, decl);
2669 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2675 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2676 where T : TypeFoldable<'tcx>
2678 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2681 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2683 where T : TypeFoldable<'tcx>
2685 self.inh.partially_normalize_associated_types_in(span,
2691 pub fn require_type_meets(&self,
2694 code: traits::ObligationCauseCode<'tcx>,
2697 self.register_bound(
2700 traits::ObligationCause::new(span, self.body_id, code));
2703 pub fn require_type_is_sized(
2707 code: traits::ObligationCauseCode<'tcx>,
2709 if !ty.references_error() {
2710 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
2711 self.require_type_meets(ty, span, code, lang_item);
2715 pub fn require_type_is_sized_deferred(
2719 code: traits::ObligationCauseCode<'tcx>,
2721 if !ty.references_error() {
2722 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2726 pub fn register_bound(
2730 cause: traits::ObligationCause<'tcx>,
2732 if !ty.references_error() {
2733 self.fulfillment_cx.borrow_mut()
2734 .register_bound(self, self.param_env, ty, def_id, cause);
2738 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2739 let t = AstConv::ast_ty_to_ty(self, ast_t);
2740 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2744 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2745 let ty = self.to_ty(ast_ty);
2746 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2748 if Self::can_contain_user_lifetime_bounds(ty) {
2749 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2750 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2751 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2757 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2758 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2759 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2762 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2763 AstConv::ast_const_to_const(self, ast_c, ty)
2766 // If the type given by the user has free regions, save it for later, since
2767 // NLL would like to enforce those. Also pass in types that involve
2768 // projections, since those can resolve to `'static` bounds (modulo #54940,
2769 // which hopefully will be fixed by the time you see this comment, dear
2770 // reader, although I have my doubts). Also pass in types with inference
2771 // types, because they may be repeated. Other sorts of things are already
2772 // sufficiently enforced with erased regions. =)
2773 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2775 T: TypeFoldable<'tcx>
2777 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2780 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2781 match self.tables.borrow().node_types().get(id) {
2783 None if self.is_tainted_by_errors() => self.tcx.types.err,
2785 bug!("no type for node {}: {} in fcx {}",
2786 id, self.tcx.hir().node_to_string(id),
2792 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2793 /// outlive the region `r`.
2794 pub fn register_wf_obligation(
2798 code: traits::ObligationCauseCode<'tcx>,
2800 // WF obligations never themselves fail, so no real need to give a detailed cause:
2801 let cause = traits::ObligationCause::new(span, self.body_id, code);
2802 self.register_predicate(
2803 traits::Obligation::new(cause, self.param_env, ty::Predicate::WellFormed(ty)),
2807 /// Registers obligations that all types appearing in `substs` are well-formed.
2808 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2809 for ty in substs.types() {
2810 if !ty.references_error() {
2811 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2816 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2817 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2818 /// trait/region obligations.
2820 /// For example, if there is a function:
2823 /// fn foo<'a,T:'a>(...)
2826 /// and a reference:
2832 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2833 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2834 pub fn add_obligations_for_parameters(&self,
2835 cause: traits::ObligationCause<'tcx>,
2836 predicates: &ty::InstantiatedPredicates<'tcx>)
2838 assert!(!predicates.has_escaping_bound_vars());
2840 debug!("add_obligations_for_parameters(predicates={:?})",
2843 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2844 self.register_predicate(obligation);
2848 // FIXME(arielb1): use this instead of field.ty everywhere
2849 // Only for fields! Returns <none> for methods>
2850 // Indifferent to privacy flags
2854 field: &'tcx ty::FieldDef,
2855 substs: SubstsRef<'tcx>,
2857 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2860 fn check_casts(&self) {
2861 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2862 for cast in deferred_cast_checks.drain(..) {
2867 fn resolve_generator_interiors(&self, def_id: DefId) {
2868 let mut generators = self.deferred_generator_interiors.borrow_mut();
2869 for (body_id, interior, kind) in generators.drain(..) {
2870 self.select_obligations_where_possible(false, |_| {});
2871 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2875 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2876 // Non-numerics get replaced with ! or () (depending on whether
2877 // feature(never_type) is enabled, unconstrained ints with i32,
2878 // unconstrained floats with f64.
2879 // Fallback becomes very dubious if we have encountered type-checking errors.
2880 // In that case, fallback to Error.
2881 // The return value indicates whether fallback has occurred.
2882 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2883 use rustc::ty::error::UnconstrainedNumeric::Neither;
2884 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2886 assert!(ty.is_ty_infer());
2887 let fallback = match self.type_is_unconstrained_numeric(ty) {
2888 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2889 UnconstrainedInt => self.tcx.types.i32,
2890 UnconstrainedFloat => self.tcx.types.f64,
2891 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2892 Neither => return false,
2894 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2895 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2899 fn select_all_obligations_or_error(&self) {
2900 debug!("select_all_obligations_or_error");
2901 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2902 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2906 /// Select as many obligations as we can at present.
2907 fn select_obligations_where_possible(
2909 fallback_has_occurred: bool,
2910 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
2912 if let Err(mut errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2913 mutate_fullfillment_errors(&mut errors);
2914 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2918 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2919 /// returns a type of `&T`, but the actual type we assign to the
2920 /// *expression* is `T`. So this function just peels off the return
2921 /// type by one layer to yield `T`.
2922 fn make_overloaded_place_return_type(&self,
2923 method: MethodCallee<'tcx>)
2924 -> ty::TypeAndMut<'tcx>
2926 // extract method return type, which will be &T;
2927 let ret_ty = method.sig.output();
2929 // method returns &T, but the type as visible to user is T, so deref
2930 ret_ty.builtin_deref(true).unwrap()
2936 base_expr: &'tcx hir::Expr,
2940 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2941 // FIXME(#18741) -- this is almost but not quite the same as the
2942 // autoderef that normal method probing does. They could likely be
2945 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2946 let mut result = None;
2947 while result.is_none() && autoderef.next().is_some() {
2948 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2950 autoderef.finalize(self);
2954 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2955 /// (and otherwise adjust) `base_expr`, looking for a type which either
2956 /// supports builtin indexing or overloaded indexing.
2957 /// This loop implements one step in that search; the autoderef loop
2958 /// is implemented by `lookup_indexing`.
2962 base_expr: &hir::Expr,
2963 autoderef: &Autoderef<'a, 'tcx>,
2966 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2967 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2968 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2975 for &unsize in &[false, true] {
2976 let mut self_ty = adjusted_ty;
2978 // We only unsize arrays here.
2979 if let ty::Array(element_ty, _) = adjusted_ty.kind {
2980 self_ty = self.tcx.mk_slice(element_ty);
2986 // If some lookup succeeds, write callee into table and extract index/element
2987 // type from the method signature.
2988 // If some lookup succeeded, install method in table
2989 let input_ty = self.next_ty_var(TypeVariableOrigin {
2990 kind: TypeVariableOriginKind::AutoDeref,
2991 span: base_expr.span,
2993 let method = self.try_overloaded_place_op(
2994 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2996 let result = method.map(|ok| {
2997 debug!("try_index_step: success, using overloaded indexing");
2998 let method = self.register_infer_ok_obligations(ok);
3000 let mut adjustments = autoderef.adjust_steps(self, needs);
3001 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3002 let mutbl = match r_mutbl {
3003 hir::MutImmutable => AutoBorrowMutability::Immutable,
3004 hir::MutMutable => AutoBorrowMutability::Mutable {
3005 // Indexing can be desugared to a method call,
3006 // so maybe we could use two-phase here.
3007 // See the documentation of AllowTwoPhase for why that's
3008 // not the case today.
3009 allow_two_phase_borrow: AllowTwoPhase::No,
3012 adjustments.push(Adjustment {
3013 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3014 target: self.tcx.mk_ref(region, ty::TypeAndMut {
3021 adjustments.push(Adjustment {
3022 kind: Adjust::Pointer(PointerCast::Unsize),
3023 target: method.sig.inputs()[0]
3026 self.apply_adjustments(base_expr, adjustments);
3028 self.write_method_call(expr.hir_id, method);
3029 (input_ty, self.make_overloaded_place_return_type(method).ty)
3031 if result.is_some() {
3039 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3040 let (tr, name) = match (op, is_mut) {
3041 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3042 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3043 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3044 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3046 (tr, ast::Ident::with_dummy_span(name))
3049 fn try_overloaded_place_op(&self,
3052 arg_tys: &[Ty<'tcx>],
3055 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3057 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3063 // Try Mut first, if needed.
3064 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3065 let method = match (needs, mut_tr) {
3066 (Needs::MutPlace, Some(trait_did)) => {
3067 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3072 // Otherwise, fall back to the immutable version.
3073 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3074 let method = match (method, imm_tr) {
3075 (None, Some(trait_did)) => {
3076 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3078 (method, _) => method,
3084 fn check_method_argument_types(
3087 expr: &'tcx hir::Expr,
3088 method: Result<MethodCallee<'tcx>, ()>,
3089 args_no_rcvr: &'tcx [hir::Expr],
3090 tuple_arguments: TupleArgumentsFlag,
3091 expected: Expectation<'tcx>,
3094 let has_error = match method {
3096 method.substs.references_error() || method.sig.references_error()
3101 let err_inputs = self.err_args(args_no_rcvr.len());
3103 let err_inputs = match tuple_arguments {
3104 DontTupleArguments => err_inputs,
3105 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3108 self.check_argument_types(
3118 return self.tcx.types.err;
3121 let method = method.unwrap();
3122 // HACK(eddyb) ignore self in the definition (see above).
3123 let expected_arg_tys = self.expected_inputs_for_expected_output(
3126 method.sig.output(),
3127 &method.sig.inputs()[1..]
3129 self.check_argument_types(
3132 &method.sig.inputs()[1..],
3133 &expected_arg_tys[..],
3135 method.sig.c_variadic,
3137 self.tcx.hir().span_if_local(method.def_id),
3142 fn self_type_matches_expected_vid(
3144 trait_ref: ty::PolyTraitRef<'tcx>,
3145 expected_vid: ty::TyVid,
3147 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3149 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3150 trait_ref, self_ty, expected_vid
3152 match self_ty.kind {
3153 ty::Infer(ty::TyVar(found_vid)) => {
3154 // FIXME: consider using `sub_root_var` here so we
3155 // can see through subtyping.
3156 let found_vid = self.root_var(found_vid);
3157 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3158 expected_vid == found_vid
3164 fn obligations_for_self_ty<'b>(
3167 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3170 // FIXME: consider using `sub_root_var` here so we
3171 // can see through subtyping.
3172 let ty_var_root = self.root_var(self_ty);
3173 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3174 self_ty, ty_var_root,
3175 self.fulfillment_cx.borrow().pending_obligations());
3179 .pending_obligations()
3181 .filter_map(move |obligation| match obligation.predicate {
3182 ty::Predicate::Projection(ref data) =>
3183 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3184 ty::Predicate::Trait(ref data) =>
3185 Some((data.to_poly_trait_ref(), obligation)),
3186 ty::Predicate::Subtype(..) => None,
3187 ty::Predicate::RegionOutlives(..) => None,
3188 ty::Predicate::TypeOutlives(..) => None,
3189 ty::Predicate::WellFormed(..) => None,
3190 ty::Predicate::ObjectSafe(..) => None,
3191 ty::Predicate::ConstEvaluatable(..) => None,
3192 // N.B., this predicate is created by breaking down a
3193 // `ClosureType: FnFoo()` predicate, where
3194 // `ClosureType` represents some `Closure`. It can't
3195 // possibly be referring to the current closure,
3196 // because we haven't produced the `Closure` for
3197 // this closure yet; this is exactly why the other
3198 // code is looking for a self type of a unresolved
3199 // inference variable.
3200 ty::Predicate::ClosureKind(..) => None,
3201 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3204 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3205 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3206 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3210 /// Generic function that factors out common logic from function calls,
3211 /// method calls and overloaded operators.
3212 fn check_argument_types(
3215 expr: &'tcx hir::Expr,
3216 fn_inputs: &[Ty<'tcx>],
3217 expected_arg_tys: &[Ty<'tcx>],
3218 args: &'tcx [hir::Expr],
3220 tuple_arguments: TupleArgumentsFlag,
3221 def_span: Option<Span>,
3224 // Grab the argument types, supplying fresh type variables
3225 // if the wrong number of arguments were supplied
3226 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3232 // All the input types from the fn signature must outlive the call
3233 // so as to validate implied bounds.
3234 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3235 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3238 let expected_arg_count = fn_inputs.len();
3240 let param_count_error = |expected_count: usize,
3245 let mut err = tcx.sess.struct_span_err_with_code(sp,
3246 &format!("this function takes {}{} but {} {} supplied",
3247 if c_variadic { "at least " } else { "" },
3248 potentially_plural_count(expected_count, "parameter"),
3249 potentially_plural_count(arg_count, "parameter"),
3250 if arg_count == 1 {"was"} else {"were"}),
3251 DiagnosticId::Error(error_code.to_owned()));
3253 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3254 err.span_label(def_s, "defined here");
3257 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3258 // remove closing `)` from the span
3259 let sugg_span = sugg_span.shrink_to_lo();
3260 err.span_suggestion(
3262 "expected the unit value `()`; create it with empty parentheses",
3264 Applicability::MachineApplicable);
3266 err.span_label(sp, format!("expected {}{}",
3267 if c_variadic { "at least " } else { "" },
3268 potentially_plural_count(expected_count, "parameter")));
3273 let mut expected_arg_tys = expected_arg_tys.to_vec();
3275 let formal_tys = if tuple_arguments == TupleArguments {
3276 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3277 match tuple_type.kind {
3278 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3279 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3280 expected_arg_tys = vec![];
3281 self.err_args(args.len())
3283 ty::Tuple(arg_types) => {
3284 expected_arg_tys = match expected_arg_tys.get(0) {
3285 Some(&ty) => match ty.kind {
3286 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3291 arg_types.iter().map(|k| k.expect_ty()).collect()
3294 span_err!(tcx.sess, sp, E0059,
3295 "cannot use call notation; the first type parameter \
3296 for the function trait is neither a tuple nor unit");
3297 expected_arg_tys = vec![];
3298 self.err_args(args.len())
3301 } else if expected_arg_count == supplied_arg_count {
3303 } else if c_variadic {
3304 if supplied_arg_count >= expected_arg_count {
3307 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3308 expected_arg_tys = vec![];
3309 self.err_args(supplied_arg_count)
3312 // is the missing argument of type `()`?
3313 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3314 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3315 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3316 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3320 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3322 expected_arg_tys = vec![];
3323 self.err_args(supplied_arg_count)
3326 debug!("check_argument_types: formal_tys={:?}",
3327 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3329 // If there is no expectation, expect formal_tys.
3330 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3336 let mut final_arg_types: Vec<(usize, Ty<'_>)> = vec![];
3338 // Check the arguments.
3339 // We do this in a pretty awful way: first we type-check any arguments
3340 // that are not closures, then we type-check the closures. This is so
3341 // that we have more information about the types of arguments when we
3342 // type-check the functions. This isn't really the right way to do this.
3343 for &check_closures in &[false, true] {
3344 debug!("check_closures={}", check_closures);
3346 // More awful hacks: before we check argument types, try to do
3347 // an "opportunistic" vtable resolution of any trait bounds on
3348 // the call. This helps coercions.
3350 self.select_obligations_where_possible(false, |errors| {
3351 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3352 self.point_at_arg_instead_of_call_if_possible(
3354 &final_arg_types[..],
3361 // For C-variadic functions, we don't have a declared type for all of
3362 // the arguments hence we only do our usual type checking with
3363 // the arguments who's types we do know.
3364 let t = if c_variadic {
3366 } else if tuple_arguments == TupleArguments {
3371 for (i, arg) in args.iter().take(t).enumerate() {
3372 // Warn only for the first loop (the "no closures" one).
3373 // Closure arguments themselves can't be diverging, but
3374 // a previous argument can, e.g., `foo(panic!(), || {})`.
3375 if !check_closures {
3376 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3379 let is_closure = match arg.kind {
3380 ExprKind::Closure(..) => true,
3384 if is_closure != check_closures {
3388 debug!("checking the argument");
3389 let formal_ty = formal_tys[i];
3391 // The special-cased logic below has three functions:
3392 // 1. Provide as good of an expected type as possible.
3393 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3395 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3397 // 2. Coerce to the most detailed type that could be coerced
3398 // to, which is `expected_ty` if `rvalue_hint` returns an
3399 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3400 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3401 // We're processing function arguments so we definitely want to use
3402 // two-phase borrows.
3403 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3404 final_arg_types.push((i, coerce_ty));
3406 // 3. Relate the expected type and the formal one,
3407 // if the expected type was used for the coercion.
3408 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3412 // We also need to make sure we at least write the ty of the other
3413 // arguments which we skipped above.
3415 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3416 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3417 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3420 for arg in args.iter().skip(expected_arg_count) {
3421 let arg_ty = self.check_expr(&arg);
3423 // There are a few types which get autopromoted when passed via varargs
3424 // in C but we just error out instead and require explicit casts.
3425 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3427 ty::Float(ast::FloatTy::F32) => {
3428 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3430 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3431 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3433 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3434 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3437 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3438 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3439 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3447 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3448 vec![self.tcx.types.err; len]
3451 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call argument expressions, we
3452 /// walk the resolved types for each argument to see if any of the `FullfillmentError`s
3453 /// reference a type argument. If they do, and there's only *one* argument that does, we point
3454 /// at the corresponding argument's expression span instead of the `fn` call path span.
3455 fn point_at_arg_instead_of_call_if_possible(
3457 errors: &mut Vec<traits::FulfillmentError<'_>>,
3458 final_arg_types: &[(usize, Ty<'tcx>)],
3460 args: &'tcx [hir::Expr],
3462 if !call_sp.desugaring_kind().is_some() {
3463 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3464 // the `?` operator.
3465 for error in errors {
3466 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3467 // Collect the argument position for all arguments that could have caused this
3468 // `FullfillmentError`.
3469 let mut referenced_in = final_arg_types.iter()
3470 .flat_map(|(i, ty)| {
3471 let ty = self.resolve_vars_if_possible(ty);
3472 // We walk the argument type because the argument's type could have
3473 // been `Option<T>`, but the `FullfillmentError` references `T`.
3475 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3478 if let (Some(ref_in), None) = (referenced_in.next(), referenced_in.next()) {
3479 // We make sure that only *one* argument matches the obligation failure
3480 // and thet the obligation's span to its expression's.
3481 error.obligation.cause.span = args[ref_in].span;
3482 error.points_at_arg_span = true;
3489 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call expression, we walk the
3490 /// `PathSegment`s and resolve their type parameters to see if any of the `FullfillmentError`s
3491 /// were caused by them. If they were, we point at the corresponding type argument's span
3492 /// instead of the `fn` call path span.
3493 fn point_at_type_arg_instead_of_call_if_possible(
3495 errors: &mut Vec<traits::FulfillmentError<'_>>,
3496 call_expr: &'tcx hir::Expr,
3498 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3499 if let hir::ExprKind::Path(qpath) = &path.kind {
3500 if let hir::QPath::Resolved(_, path) = &qpath {
3501 for error in errors {
3502 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3503 // If any of the type arguments in this path segment caused the
3504 // `FullfillmentError`, point at its span (#61860).
3505 for arg in path.segments.iter()
3506 .filter_map(|seg| seg.args.as_ref())
3507 .flat_map(|a| a.args.iter())
3509 if let hir::GenericArg::Type(hir_ty) = &arg {
3510 if let hir::TyKind::Path(
3511 hir::QPath::TypeRelative(..),
3513 // Avoid ICE with associated types. As this is best
3514 // effort only, it's ok to ignore the case. It
3515 // would trigger in `is_send::<T::AssocType>();`
3516 // from `typeck-default-trait-impl-assoc-type.rs`.
3518 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
3519 let ty = self.resolve_vars_if_possible(&ty);
3520 if ty == predicate.skip_binder().self_ty() {
3521 error.obligation.cause.span = hir_ty.span;
3533 // AST fragment checking
3536 expected: Expectation<'tcx>)
3542 ast::LitKind::Str(..) => tcx.mk_static_str(),
3543 ast::LitKind::ByteStr(ref v) => {
3544 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3545 tcx.mk_array(tcx.types.u8, v.len() as u64))
3547 ast::LitKind::Byte(_) => tcx.types.u8,
3548 ast::LitKind::Char(_) => tcx.types.char,
3549 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3550 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3551 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3552 let opt_ty = expected.to_option(self).and_then(|ty| {
3554 ty::Int(_) | ty::Uint(_) => Some(ty),
3555 ty::Char => Some(tcx.types.u8),
3556 ty::RawPtr(..) => Some(tcx.types.usize),
3557 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3561 opt_ty.unwrap_or_else(|| self.next_int_var())
3563 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3564 ast::LitKind::FloatUnsuffixed(_) => {
3565 let opt_ty = expected.to_option(self).and_then(|ty| {
3567 ty::Float(_) => Some(ty),
3571 opt_ty.unwrap_or_else(|| self.next_float_var())
3573 ast::LitKind::Bool(_) => tcx.types.bool,
3574 ast::LitKind::Err(_) => tcx.types.err,
3578 // Determine the `Self` type, using fresh variables for all variables
3579 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3580 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3582 pub fn impl_self_ty(&self,
3583 span: Span, // (potential) receiver for this impl
3585 -> TypeAndSubsts<'tcx> {
3586 let ity = self.tcx.type_of(did);
3587 debug!("impl_self_ty: ity={:?}", ity);
3589 let substs = self.fresh_substs_for_item(span, did);
3590 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3592 TypeAndSubsts { substs: substs, ty: substd_ty }
3595 /// Unifies the output type with the expected type early, for more coercions
3596 /// and forward type information on the input expressions.
3597 fn expected_inputs_for_expected_output(&self,
3599 expected_ret: Expectation<'tcx>,
3600 formal_ret: Ty<'tcx>,
3601 formal_args: &[Ty<'tcx>])
3603 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3604 let ret_ty = match expected_ret.only_has_type(self) {
3606 None => return Vec::new()
3608 let expect_args = self.fudge_inference_if_ok(|| {
3609 // Attempt to apply a subtyping relationship between the formal
3610 // return type (likely containing type variables if the function
3611 // is polymorphic) and the expected return type.
3612 // No argument expectations are produced if unification fails.
3613 let origin = self.misc(call_span);
3614 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3616 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3617 // to identity so the resulting type is not constrained.
3620 // Process any obligations locally as much as
3621 // we can. We don't care if some things turn
3622 // out unconstrained or ambiguous, as we're
3623 // just trying to get hints here.
3624 self.save_and_restore_in_snapshot_flag(|_| {
3625 let mut fulfill = TraitEngine::new(self.tcx);
3626 for obligation in ok.obligations {
3627 fulfill.register_predicate_obligation(self, obligation);
3629 fulfill.select_where_possible(self)
3630 }).map_err(|_| ())?;
3632 Err(_) => return Err(()),
3635 // Record all the argument types, with the substitutions
3636 // produced from the above subtyping unification.
3637 Ok(formal_args.iter().map(|ty| {
3638 self.resolve_vars_if_possible(ty)
3640 }).unwrap_or_default();
3641 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3642 formal_args, formal_ret,
3643 expect_args, expected_ret);
3647 pub fn check_struct_path(&self,
3650 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3651 let path_span = match *qpath {
3652 QPath::Resolved(_, ref path) => path.span,
3653 QPath::TypeRelative(ref qself, _) => qself.span
3655 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3656 let variant = match def {
3658 self.set_tainted_by_errors();
3661 Res::Def(DefKind::Variant, _) => {
3663 ty::Adt(adt, substs) => {
3664 Some((adt.variant_of_res(def), adt.did, substs))
3666 _ => bug!("unexpected type: {:?}", ty)
3669 Res::Def(DefKind::Struct, _)
3670 | Res::Def(DefKind::Union, _)
3671 | Res::Def(DefKind::TyAlias, _)
3672 | Res::Def(DefKind::AssocTy, _)
3673 | Res::SelfTy(..) => {
3675 ty::Adt(adt, substs) if !adt.is_enum() => {
3676 Some((adt.non_enum_variant(), adt.did, substs))
3681 _ => bug!("unexpected definition: {:?}", def)
3684 if let Some((variant, did, substs)) = variant {
3685 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3686 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3688 // Check bounds on type arguments used in the path.
3689 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
3690 let cause = traits::ObligationCause::new(
3693 traits::ItemObligation(did),
3695 self.add_obligations_for_parameters(cause, &bounds);
3699 struct_span_err!(self.tcx.sess, path_span, E0071,
3700 "expected struct, variant or union type, found {}",
3701 ty.sort_string(self.tcx))
3702 .span_label(path_span, "not a struct")
3708 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3709 // The newly resolved definition is written into `type_dependent_defs`.
3710 fn finish_resolving_struct_path(&self,
3717 QPath::Resolved(ref maybe_qself, ref path) => {
3718 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3719 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3722 QPath::TypeRelative(ref qself, ref segment) => {
3723 let ty = self.to_ty(qself);
3725 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3730 let result = AstConv::associated_path_to_ty(
3739 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3740 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3742 // Write back the new resolution.
3743 self.write_resolution(hir_id, result);
3745 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3750 /// Resolves an associated value path into a base type and associated constant, or method
3751 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3752 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3756 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3758 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3759 let (ty, qself, item_segment) = match *qpath {
3760 QPath::Resolved(ref opt_qself, ref path) => {
3762 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3763 &path.segments[..]);
3765 QPath::TypeRelative(ref qself, ref segment) => {
3766 (self.to_ty(qself), qself, segment)
3769 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3770 // Return directly on cache hit. This is useful to avoid doubly reporting
3771 // errors with default match binding modes. See #44614.
3772 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3773 .unwrap_or(Res::Err);
3774 return (def, Some(ty), slice::from_ref(&**item_segment));
3776 let item_name = item_segment.ident;
3777 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3778 let result = match error {
3779 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3780 _ => Err(ErrorReported),
3782 if item_name.name != kw::Invalid {
3783 self.report_method_error(
3787 SelfSource::QPath(qself),
3790 ).map(|mut e| e.emit());
3795 // Write back the new resolution.
3796 self.write_resolution(hir_id, result);
3798 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3800 slice::from_ref(&**item_segment),
3804 pub fn check_decl_initializer(
3806 local: &'tcx hir::Local,
3807 init: &'tcx hir::Expr,
3809 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3810 // for #42640 (default match binding modes).
3813 let ref_bindings = local.pat.contains_explicit_ref_binding();
3815 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3816 if let Some(m) = ref_bindings {
3817 // Somewhat subtle: if we have a `ref` binding in the pattern,
3818 // we want to avoid introducing coercions for the RHS. This is
3819 // both because it helps preserve sanity and, in the case of
3820 // ref mut, for soundness (issue #23116). In particular, in
3821 // the latter case, we need to be clear that the type of the
3822 // referent for the reference that results is *equal to* the
3823 // type of the place it is referencing, and not some
3824 // supertype thereof.
3825 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3826 self.demand_eqtype(init.span, local_ty, init_ty);
3829 self.check_expr_coercable_to_type(init, local_ty)
3833 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3834 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3835 self.write_ty(local.hir_id, t);
3837 if let Some(ref init) = local.init {
3838 let init_ty = self.check_decl_initializer(local, &init);
3839 self.overwrite_local_ty_if_err(local, t, init_ty);
3842 self.check_pat_top(&local.pat, t, None);
3843 let pat_ty = self.node_ty(local.pat.hir_id);
3844 self.overwrite_local_ty_if_err(local, t, pat_ty);
3847 fn overwrite_local_ty_if_err(&self, local: &'tcx hir::Local, decl_ty: Ty<'tcx>, ty: Ty<'tcx>) {
3848 if ty.references_error() {
3849 // Override the types everywhere with `types.err` to avoid knock down errors.
3850 self.write_ty(local.hir_id, ty);
3851 self.write_ty(local.pat.hir_id, ty);
3852 let local_ty = LocalTy {
3856 self.locals.borrow_mut().insert(local.hir_id, local_ty);
3857 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
3861 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3862 // Don't do all the complex logic below for `DeclItem`.
3864 hir::StmtKind::Item(..) => return,
3865 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3868 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3870 // Hide the outer diverging and `has_errors` flags.
3871 let old_diverges = self.diverges.get();
3872 let old_has_errors = self.has_errors.get();
3873 self.diverges.set(Diverges::Maybe);
3874 self.has_errors.set(false);
3877 hir::StmtKind::Local(ref l) => {
3878 self.check_decl_local(&l);
3881 hir::StmtKind::Item(_) => {}
3882 hir::StmtKind::Expr(ref expr) => {
3883 // Check with expected type of `()`.
3884 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3886 hir::StmtKind::Semi(ref expr) => {
3887 self.check_expr(&expr);
3891 // Combine the diverging and `has_error` flags.
3892 self.diverges.set(self.diverges.get() | old_diverges);
3893 self.has_errors.set(self.has_errors.get() | old_has_errors);
3896 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3897 let unit = self.tcx.mk_unit();
3898 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3900 // if the block produces a `!` value, that can always be
3901 // (effectively) coerced to unit.
3903 self.demand_suptype(blk.span, unit, ty);
3907 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
3908 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
3909 /// when given code like the following:
3911 /// if false { return 0i32; } else { 1u32 }
3912 /// // ^^^^ point at this instead of the whole `if` expression
3914 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
3915 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
3916 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
3917 self.in_progress_tables
3918 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
3919 .and_then(|arm_ty| {
3920 if arm_ty.is_never() {
3923 Some(match &arm.body.kind {
3924 // Point at the tail expression when possible.
3925 hir::ExprKind::Block(block, _) => block.expr
3928 .unwrap_or(block.span),
3934 if arm_spans.len() == 1 {
3935 return arm_spans[0];
3941 fn check_block_with_expected(
3943 blk: &'tcx hir::Block,
3944 expected: Expectation<'tcx>,
3947 let mut fcx_ps = self.ps.borrow_mut();
3948 let unsafety_state = fcx_ps.recurse(blk);
3949 replace(&mut *fcx_ps, unsafety_state)
3952 // In some cases, blocks have just one exit, but other blocks
3953 // can be targeted by multiple breaks. This can happen both
3954 // with labeled blocks as well as when we desugar
3955 // a `try { ... }` expression.
3959 // 'a: { if true { break 'a Err(()); } Ok(()) }
3961 // Here we would wind up with two coercions, one from
3962 // `Err(())` and the other from the tail expression
3963 // `Ok(())`. If the tail expression is omitted, that's a
3964 // "forced unit" -- unless the block diverges, in which
3965 // case we can ignore the tail expression (e.g., `'a: {
3966 // break 'a 22; }` would not force the type of the block
3968 let tail_expr = blk.expr.as_ref();
3969 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3970 let coerce = if blk.targeted_by_break {
3971 CoerceMany::new(coerce_to_ty)
3973 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3974 Some(e) => slice::from_ref(e),
3977 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3980 let prev_diverges = self.diverges.get();
3981 let ctxt = BreakableCtxt {
3982 coerce: Some(coerce),
3986 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3987 for s in &blk.stmts {
3991 // check the tail expression **without** holding the
3992 // `enclosing_breakables` lock below.
3993 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3995 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3996 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3997 let coerce = ctxt.coerce.as_mut().unwrap();
3998 if let Some(tail_expr_ty) = tail_expr_ty {
3999 let tail_expr = tail_expr.unwrap();
4000 let span = self.get_expr_coercion_span(tail_expr);
4001 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4002 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4004 // Subtle: if there is no explicit tail expression,
4005 // that is typically equivalent to a tail expression
4006 // of `()` -- except if the block diverges. In that
4007 // case, there is no value supplied from the tail
4008 // expression (assuming there are no other breaks,
4009 // this implies that the type of the block will be
4012 // #41425 -- label the implicit `()` as being the
4013 // "found type" here, rather than the "expected type".
4014 if !self.diverges.get().is_always() {
4015 // #50009 -- Do not point at the entire fn block span, point at the return type
4016 // span, as it is the cause of the requirement, and
4017 // `consider_hint_about_removing_semicolon` will point at the last expression
4018 // if it were a relevant part of the error. This improves usability in editors
4019 // that highlight errors inline.
4020 let mut sp = blk.span;
4021 let mut fn_span = None;
4022 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4023 let ret_sp = decl.output.span();
4024 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4025 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4026 // output would otherwise be incorrect and even misleading. Make sure
4027 // the span we're aiming at correspond to a `fn` body.
4028 if block_sp == blk.span {
4030 fn_span = Some(ident.span);
4034 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4035 if let Some(expected_ty) = expected.only_has_type(self) {
4036 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4038 if let Some(fn_span) = fn_span {
4041 "implicitly returns `()` as its body has no tail or `return` \
4051 // If we can break from the block, then the block's exit is always reachable
4052 // (... as long as the entry is reachable) - regardless of the tail of the block.
4053 self.diverges.set(prev_diverges);
4056 let mut ty = ctxt.coerce.unwrap().complete(self);
4058 if self.has_errors.get() || ty.references_error() {
4059 ty = self.tcx.types.err
4062 self.write_ty(blk.hir_id, ty);
4064 *self.ps.borrow_mut() = prev;
4068 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4069 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4071 Node::Item(&hir::Item {
4072 node: hir::ItemKind::Fn(_, _, _, body_id), ..
4074 Node::ImplItem(&hir::ImplItem {
4075 node: hir::ImplItemKind::Method(_, body_id), ..
4077 let body = self.tcx.hir().body(body_id);
4078 if let ExprKind::Block(block, _) = &body.value.kind {
4079 return Some(block.span);
4087 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4088 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
4089 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4090 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4093 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4094 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
4096 Node::Item(&hir::Item {
4097 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
4099 // This is less than ideal, it will not suggest a return type span on any
4100 // method called `main`, regardless of whether it is actually the entry point,
4101 // but it will still present it as the reason for the expected type.
4102 Some((decl, ident, ident.name != sym::main))
4104 Node::TraitItem(&hir::TraitItem {
4105 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
4108 }) => Some((decl, ident, true)),
4109 Node::ImplItem(&hir::ImplItem {
4110 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
4113 }) => Some((decl, ident, false)),
4118 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4119 /// suggestion can be made, `None` otherwise.
4120 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
4121 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4122 // `while` before reaching it, as block tail returns are not available in them.
4123 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4124 let parent = self.tcx.hir().get(blk_id);
4125 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4129 /// On implicit return expressions with mismatched types, provides the following suggestions:
4131 /// - Points out the method's return type as the reason for the expected type.
4132 /// - Possible missing semicolon.
4133 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4134 pub fn suggest_mismatched_types_on_tail(
4136 err: &mut DiagnosticBuilder<'tcx>,
4137 expression: &'tcx hir::Expr,
4143 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4144 let mut pointing_at_return_type = false;
4145 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4146 pointing_at_return_type = self.suggest_missing_return_type(
4147 err, &fn_decl, expected, found, can_suggest);
4149 self.suggest_ref_or_into(err, expression, expected, found);
4150 self.suggest_boxing_when_appropriate(err, expression, expected, found);
4151 pointing_at_return_type
4154 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4155 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4157 /// fn foo(x: usize) -> usize { x }
4158 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4162 err: &mut DiagnosticBuilder<'tcx>,
4167 let hir = self.tcx.hir();
4168 let (def_id, sig) = match found.kind {
4169 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4170 ty::Closure(def_id, substs) => {
4171 // We don't use `closure_sig` to account for malformed closures like
4172 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4173 let closure_sig_ty = substs.closure_sig_ty(def_id, self.tcx);
4174 (def_id, match closure_sig_ty.kind {
4175 ty::FnPtr(sig) => sig,
4183 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4185 let sig = self.normalize_associated_types_in(expr.span, &sig);
4186 if self.can_coerce(sig.output(), expected) {
4187 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4188 (String::new(), Applicability::MachineApplicable)
4190 ("...".to_string(), Applicability::HasPlaceholders)
4192 let mut msg = "call this function";
4193 match hir.get_if_local(def_id) {
4194 Some(Node::Item(hir::Item {
4195 node: ItemKind::Fn(.., body_id),
4198 Some(Node::ImplItem(hir::ImplItem {
4199 node: hir::ImplItemKind::Method(_, body_id),
4202 Some(Node::TraitItem(hir::TraitItem {
4203 node: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4206 let body = hir.body(*body_id);
4207 sugg_call = body.params.iter()
4208 .map(|param| match ¶m.pat.kind {
4209 hir::PatKind::Binding(_, _, ident, None)
4210 if ident.name != kw::SelfLower => ident.to_string(),
4211 _ => "_".to_string(),
4212 }).collect::<Vec<_>>().join(", ");
4214 Some(Node::Expr(hir::Expr {
4215 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4216 span: full_closure_span,
4219 if *full_closure_span == expr.span {
4222 err.span_label(*closure_span, "closure defined here");
4223 msg = "call this closure";
4224 let body = hir.body(*body_id);
4225 sugg_call = body.params.iter()
4226 .map(|param| match ¶m.pat.kind {
4227 hir::PatKind::Binding(_, _, ident, None)
4228 if ident.name != kw::SelfLower => ident.to_string(),
4229 _ => "_".to_string(),
4230 }).collect::<Vec<_>>().join(", ");
4232 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4233 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4234 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4235 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4236 msg = "instantiate this tuple variant";
4238 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4239 msg = "instantiate this tuple struct";
4244 Some(Node::ForeignItem(hir::ForeignItem {
4245 node: hir::ForeignItemKind::Fn(_, idents, _),
4248 Some(Node::TraitItem(hir::TraitItem {
4249 node: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4251 })) => sugg_call = idents.iter()
4252 .map(|ident| if ident.name != kw::SelfLower {
4256 }).collect::<Vec<_>>()
4260 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4261 err.span_suggestion(
4263 &format!("use parentheses to {}", msg),
4264 format!("{}({})", code, sugg_call),
4273 pub fn suggest_ref_or_into(
4275 err: &mut DiagnosticBuilder<'tcx>,
4280 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4281 err.span_suggestion(
4285 Applicability::MachineApplicable,
4287 } else if let (ty::FnDef(def_id, ..), true) = (
4289 self.suggest_fn_call(err, expr, expected, found),
4291 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4292 let sp = self.sess().source_map().def_span(sp);
4293 err.span_label(sp, &format!("{} defined here", found));
4295 } else if !self.check_for_cast(err, expr, found, expected) {
4296 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4300 let methods = self.get_conversion_methods(expr.span, expected, found);
4301 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4302 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4303 .filter_map(|(receiver, method)| {
4304 let method_call = format!(".{}()", method.ident);
4305 if receiver.ends_with(&method_call) {
4306 None // do not suggest code that is already there (#53348)
4308 let method_call_list = [".to_vec()", ".to_string()"];
4309 let sugg = if receiver.ends_with(".clone()")
4310 && method_call_list.contains(&method_call.as_str()) {
4311 let max_len = receiver.rfind(".").unwrap();
4312 format!("{}{}", &receiver[..max_len], method_call)
4314 format!("{}{}", receiver, method_call)
4316 Some(if is_struct_pat_shorthand_field {
4317 format!("{}: {}", receiver, sugg)
4323 if suggestions.peek().is_some() {
4324 err.span_suggestions(
4326 "try using a conversion method",
4328 Applicability::MaybeIncorrect,
4335 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4336 /// in the heap by calling `Box::new()`.
4337 fn suggest_boxing_when_appropriate(
4339 err: &mut DiagnosticBuilder<'tcx>,
4344 if self.tcx.hir().is_const_context(expr.hir_id) {
4345 // Do not suggest `Box::new` in const context.
4348 if !expected.is_box() || found.is_box() {
4351 let boxed_found = self.tcx.mk_box(found);
4352 if let (true, Ok(snippet)) = (
4353 self.can_coerce(boxed_found, expected),
4354 self.sess().source_map().span_to_snippet(expr.span),
4356 err.span_suggestion(
4358 "store this in the heap by calling `Box::new`",
4359 format!("Box::new({})", snippet),
4360 Applicability::MachineApplicable,
4362 err.note("for more on the distinction between the stack and the \
4363 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4364 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4365 https://doc.rust-lang.org/std/boxed/index.html");
4370 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4374 /// bar_that_returns_u32()
4378 /// This routine checks if the return expression in a block would make sense on its own as a
4379 /// statement and the return type has been left as default or has been specified as `()`. If so,
4380 /// it suggests adding a semicolon.
4381 fn suggest_missing_semicolon(
4383 err: &mut DiagnosticBuilder<'tcx>,
4384 expression: &'tcx hir::Expr,
4388 if expected.is_unit() {
4389 // `BlockTailExpression` only relevant if the tail expr would be
4390 // useful on its own.
4391 match expression.kind {
4392 ExprKind::Call(..) |
4393 ExprKind::MethodCall(..) |
4394 ExprKind::Loop(..) |
4395 ExprKind::Match(..) |
4396 ExprKind::Block(..) => {
4397 let sp = self.tcx.sess.source_map().next_point(cause_span);
4398 err.span_suggestion(
4400 "try adding a semicolon",
4402 Applicability::MachineApplicable);
4409 /// A possible error is to forget to add a return type that is needed:
4413 /// bar_that_returns_u32()
4417 /// This routine checks if the return type is left as default, the method is not part of an
4418 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4420 fn suggest_missing_return_type(
4422 err: &mut DiagnosticBuilder<'tcx>,
4423 fn_decl: &hir::FnDecl,
4428 // Only suggest changing the return type for methods that
4429 // haven't set a return type at all (and aren't `fn main()` or an impl).
4430 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4431 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4432 err.span_suggestion(
4434 "try adding a return type",
4435 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4436 Applicability::MachineApplicable);
4439 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4440 err.span_label(span, "possibly return type missing here?");
4443 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4444 // `fn main()` must return `()`, do not suggest changing return type
4445 err.span_label(span, "expected `()` because of default return type");
4448 // expectation was caused by something else, not the default return
4449 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4450 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4451 // Only point to return type if the expected type is the return type, as if they
4452 // are not, the expectation must have been caused by something else.
4453 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4455 let ty = AstConv::ast_ty_to_ty(self, ty);
4456 debug!("suggest_missing_return_type: return type {:?}", ty);
4457 debug!("suggest_missing_return_type: expected type {:?}", ty);
4458 if ty.kind == expected.kind {
4459 err.span_label(sp, format!("expected `{}` because of return type",
4468 /// A possible error is to forget to add `.await` when using futures:
4471 /// async fn make_u32() -> u32 {
4475 /// fn take_u32(x: u32) {}
4477 /// async fn foo() {
4478 /// let x = make_u32();
4483 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4484 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4485 /// `.await` to the tail of the expression.
4486 fn suggest_missing_await(
4488 err: &mut DiagnosticBuilder<'tcx>,
4493 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4494 // body isn't `async`.
4495 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4496 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4497 let body = self.tcx().hir().body(body_id);
4498 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
4500 // Check for `Future` implementations by constructing a predicate to
4501 // prove: `<T as Future>::Output == U`
4502 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4503 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4504 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4505 // `<T as Future>::Output`
4506 projection_ty: ty::ProjectionTy {
4508 substs: self.tcx.mk_substs_trait(
4510 self.fresh_substs_for_item(sp, item_def_id)
4517 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4518 if self.infcx.predicate_may_hold(&obligation) {
4519 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4520 err.span_suggestion(
4522 "consider using `.await` here",
4523 format!("{}.await", code),
4524 Applicability::MaybeIncorrect,
4532 /// A common error is to add an extra semicolon:
4535 /// fn foo() -> usize {
4540 /// This routine checks if the final statement in a block is an
4541 /// expression with an explicit semicolon whose type is compatible
4542 /// with `expected_ty`. If so, it suggests removing the semicolon.
4543 fn consider_hint_about_removing_semicolon(
4545 blk: &'tcx hir::Block,
4546 expected_ty: Ty<'tcx>,
4547 err: &mut DiagnosticBuilder<'_>,
4549 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4550 err.span_suggestion(
4552 "consider removing this semicolon",
4554 Applicability::MachineApplicable,
4559 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4560 // Be helpful when the user wrote `{... expr;}` and
4561 // taking the `;` off is enough to fix the error.
4562 let last_stmt = blk.stmts.last()?;
4563 let last_expr = match last_stmt.node {
4564 hir::StmtKind::Semi(ref e) => e,
4567 let last_expr_ty = self.node_ty(last_expr.hir_id);
4568 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4571 let original_span = original_sp(last_stmt.span, blk.span);
4572 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4575 // Instantiates the given path, which must refer to an item with the given
4576 // number of type parameters and type.
4577 pub fn instantiate_value_path(&self,
4578 segments: &[hir::PathSegment],
4579 self_ty: Option<Ty<'tcx>>,
4583 -> (Ty<'tcx>, Res) {
4585 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4594 let path_segs = match res {
4595 Res::Local(_) | Res::SelfCtor(_) => vec![],
4596 Res::Def(kind, def_id) =>
4597 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4598 _ => bug!("instantiate_value_path on {:?}", res),
4601 let mut user_self_ty = None;
4602 let mut is_alias_variant_ctor = false;
4604 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4605 if let Some(self_ty) = self_ty {
4606 let adt_def = self_ty.ty_adt_def().unwrap();
4607 user_self_ty = Some(UserSelfTy {
4608 impl_def_id: adt_def.did,
4611 is_alias_variant_ctor = true;
4614 Res::Def(DefKind::Method, def_id)
4615 | Res::Def(DefKind::AssocConst, def_id) => {
4616 let container = tcx.associated_item(def_id).container;
4617 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4619 ty::TraitContainer(trait_did) => {
4620 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4622 ty::ImplContainer(impl_def_id) => {
4623 if segments.len() == 1 {
4624 // `<T>::assoc` will end up here, and so
4625 // can `T::assoc`. It this came from an
4626 // inherent impl, we need to record the
4627 // `T` for posterity (see `UserSelfTy` for
4629 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4630 user_self_ty = Some(UserSelfTy {
4641 // Now that we have categorized what space the parameters for each
4642 // segment belong to, let's sort out the parameters that the user
4643 // provided (if any) into their appropriate spaces. We'll also report
4644 // errors if type parameters are provided in an inappropriate place.
4646 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4647 let generics_has_err = AstConv::prohibit_generics(
4648 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4649 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4656 if let Res::Local(hid) = res {
4657 let ty = self.local_ty(span, hid).decl_ty;
4658 let ty = self.normalize_associated_types_in(span, &ty);
4659 self.write_ty(hir_id, ty);
4663 if generics_has_err {
4664 // Don't try to infer type parameters when prohibited generic arguments were given.
4665 user_self_ty = None;
4668 // Now we have to compare the types that the user *actually*
4669 // provided against the types that were *expected*. If the user
4670 // did not provide any types, then we want to substitute inference
4671 // variables. If the user provided some types, we may still need
4672 // to add defaults. If the user provided *too many* types, that's
4675 let mut infer_args_for_err = FxHashSet::default();
4676 for &PathSeg(def_id, index) in &path_segs {
4677 let seg = &segments[index];
4678 let generics = tcx.generics_of(def_id);
4679 // Argument-position `impl Trait` is treated as a normal generic
4680 // parameter internally, but we don't allow users to specify the
4681 // parameter's value explicitly, so we have to do some error-
4683 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4688 false, // `is_method_call`
4690 if suppress_errors {
4691 infer_args_for_err.insert(index);
4692 self.set_tainted_by_errors(); // See issue #53251.
4696 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4697 tcx.generics_of(*def_id).has_self
4698 }).unwrap_or(false);
4700 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4701 let ty = self.impl_self_ty(span, impl_def_id).ty;
4702 let adt_def = ty.ty_adt_def();
4705 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4706 let variant = adt_def.non_enum_variant();
4707 let ctor_def_id = variant.ctor_def_id.unwrap();
4709 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4714 let mut err = tcx.sess.struct_span_err(span,
4715 "the `Self` constructor can only be used with tuple or unit structs");
4716 if let Some(adt_def) = adt_def {
4717 match adt_def.adt_kind() {
4719 err.help("did you mean to use one of the enum's variants?");
4723 err.span_suggestion(
4725 "use curly brackets",
4726 String::from("Self { /* fields */ }"),
4727 Applicability::HasPlaceholders,
4734 return (tcx.types.err, res)
4740 let def_id = res.def_id();
4742 // The things we are substituting into the type should not contain
4743 // escaping late-bound regions, and nor should the base type scheme.
4744 let ty = tcx.type_of(def_id);
4746 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4752 // Provide the generic args, and whether types should be inferred.
4754 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4757 // If we've encountered an `impl Trait`-related error, we're just
4758 // going to infer the arguments for better error messages.
4759 if !infer_args_for_err.contains(&index) {
4760 // Check whether the user has provided generic arguments.
4761 if let Some(ref data) = segments[index].args {
4762 return (Some(data), segments[index].infer_args);
4765 return (None, segments[index].infer_args);
4770 // Provide substitutions for parameters for which (valid) arguments have been provided.
4772 match (¶m.kind, arg) {
4773 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4774 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4776 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4777 self.to_ty(ty).into()
4779 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4780 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4782 _ => unreachable!(),
4785 // Provide substitutions for parameters for which arguments are inferred.
4786 |substs, param, infer_args| {
4788 GenericParamDefKind::Lifetime => {
4789 self.re_infer(Some(param), span).unwrap().into()
4791 GenericParamDefKind::Type { has_default, .. } => {
4792 if !infer_args && has_default {
4793 // If we have a default, then we it doesn't matter that we're not
4794 // inferring the type arguments: we provide the default where any
4796 let default = tcx.type_of(param.def_id);
4799 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4802 // If no type arguments were provided, we have to infer them.
4803 // This case also occurs as a result of some malformed input, e.g.
4804 // a lifetime argument being given instead of a type parameter.
4805 // Using inference instead of `Error` gives better error messages.
4806 self.var_for_def(span, param)
4809 GenericParamDefKind::Const => {
4810 // FIXME(const_generics:defaults)
4811 // No const parameters were provided, we have to infer them.
4812 self.var_for_def(span, param)
4817 assert!(!substs.has_escaping_bound_vars());
4818 assert!(!ty.has_escaping_bound_vars());
4820 // First, store the "user substs" for later.
4821 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4823 self.add_required_obligations(span, def_id, &substs);
4825 // Substitute the values for the type parameters into the type of
4826 // the referenced item.
4827 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4829 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4830 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4831 // is inherent, there is no `Self` parameter; instead, the impl needs
4832 // type parameters, which we can infer by unifying the provided `Self`
4833 // with the substituted impl type.
4834 // This also occurs for an enum variant on a type alias.
4835 let ty = tcx.type_of(impl_def_id);
4837 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4838 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4839 Ok(ok) => self.register_infer_ok_obligations(ok),
4841 self.tcx.sess.delay_span_bug(span, &format!(
4842 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4850 self.check_rustc_args_require_const(def_id, hir_id, span);
4852 debug!("instantiate_value_path: type of {:?} is {:?}",
4855 self.write_substs(hir_id, substs);
4857 (ty_substituted, res)
4860 /// Add all the obligations that are required, substituting and normalized appropriately.
4861 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
4862 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
4864 for (i, mut obligation) in traits::predicates_for_generics(
4865 traits::ObligationCause::new(
4868 traits::ItemObligation(def_id),
4872 ).into_iter().enumerate() {
4873 // This makes the error point at the bound, but we want to point at the argument
4874 if let Some(span) = spans.get(i) {
4875 obligation.cause.code = traits::BindingObligation(def_id, *span);
4877 self.register_predicate(obligation);
4881 fn check_rustc_args_require_const(&self,
4885 // We're only interested in functions tagged with
4886 // #[rustc_args_required_const], so ignore anything that's not.
4887 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4891 // If our calling expression is indeed the function itself, we're good!
4892 // If not, generate an error that this can only be called directly.
4893 if let Node::Expr(expr) = self.tcx.hir().get(
4894 self.tcx.hir().get_parent_node(hir_id))
4896 if let ExprKind::Call(ref callee, ..) = expr.kind {
4897 if callee.hir_id == hir_id {
4903 self.tcx.sess.span_err(span, "this function can only be invoked \
4904 directly, not through a function pointer");
4907 // Resolves `typ` by a single level if `typ` is a type variable.
4908 // If no resolution is possible, then an error is reported.
4909 // Numeric inference variables may be left unresolved.
4910 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4911 let ty = self.resolve_type_vars_with_obligations(ty);
4912 if !ty.is_ty_var() {
4915 if !self.is_tainted_by_errors() {
4916 self.need_type_info_err((**self).body_id, sp, ty)
4917 .note("type must be known at this point")
4920 self.demand_suptype(sp, self.tcx.types.err, ty);
4925 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4928 ctxt: BreakableCtxt<'tcx>,
4930 ) -> (BreakableCtxt<'tcx>, R) {
4933 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4934 index = enclosing_breakables.stack.len();
4935 enclosing_breakables.by_id.insert(id, index);
4936 enclosing_breakables.stack.push(ctxt);
4940 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4941 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4942 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4943 enclosing_breakables.stack.pop().expect("missing breakable context")
4948 /// Instantiate a QueryResponse in a probe context, without a
4949 /// good ObligationCause.
4950 fn probe_instantiate_query_response(
4953 original_values: &OriginalQueryValues<'tcx>,
4954 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4955 ) -> InferResult<'tcx, Ty<'tcx>>
4957 self.instantiate_query_response_and_region_obligations(
4958 &traits::ObligationCause::misc(span, self.body_id),
4964 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4965 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4966 let mut contained_in_place = false;
4968 while let hir::Node::Expr(parent_expr) =
4969 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4971 match &parent_expr.kind {
4972 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4973 if lhs.hir_id == expr_id {
4974 contained_in_place = true;
4980 expr_id = parent_expr.hir_id;
4987 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4988 let own_counts = generics.own_counts();
4990 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4996 if own_counts.types == 0 {
5000 // Make a vector of booleans initially `false`; set to `true` when used.
5001 let mut types_used = vec![false; own_counts.types];
5003 for leaf_ty in ty.walk() {
5004 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5005 debug!("found use of ty param num {}", index);
5006 types_used[index as usize - own_counts.lifetimes] = true;
5007 } else if let ty::Error = leaf_ty.kind {
5008 // If there is already another error, do not emit
5009 // an error for not using a type parameter.
5010 assert!(tcx.sess.has_errors());
5015 let types = generics.params.iter().filter(|param| match param.kind {
5016 ty::GenericParamDefKind::Type { .. } => true,
5019 for (&used, param) in types_used.iter().zip(types) {
5021 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5022 let span = tcx.hir().span(id);
5023 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5024 .span_label(span, "unused type parameter")
5030 fn fatally_break_rust(sess: &Session) {
5031 let handler = sess.diagnostic();
5032 handler.span_bug_no_panic(
5034 "It looks like you're trying to break rust; would you like some ICE?",
5036 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5037 handler.note_without_error(
5038 "we would appreciate a joke overview: \
5039 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5041 handler.note_without_error(&format!("rustc {} running on {}",
5042 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5043 crate::session::config::host_triple(),
5047 fn potentially_plural_count(count: usize, word: &str) -> String {
5048 format!("{} {}{}", count, word, pluralise!(count))