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
80 mod generator_interior;
90 use crate::astconv::{AstConv, GenericArgCountMismatch, PathSeg};
91 use crate::middle::lang_items;
92 use rustc::hir::map::blocks::FnLikeNode;
93 use rustc::middle::region;
94 use rustc::mir::interpret::ConstValue;
95 use rustc::ty::adjustment::{
96 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast,
98 use rustc::ty::fold::{TypeFoldable, TypeFolder};
99 use rustc::ty::layout::VariantIdx;
100 use rustc::ty::query::Providers;
101 use rustc::ty::subst::{GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSelfTy, UserSubsts};
102 use rustc::ty::util::{Discr, IntTypeExt, Representability};
104 self, AdtKind, CanonicalUserType, Const, GenericParamDefKind, RegionKind, ToPolyTraitRef,
105 ToPredicate, Ty, TyCtxt, UserType, WithConstness,
108 use rustc_ast::util::parser::ExprPrecedence;
109 use rustc_attr as attr;
110 use rustc_data_structures::captures::Captures;
111 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
112 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
113 use rustc_hir as hir;
114 use rustc_hir::def::{CtorOf, DefKind, Res};
115 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId, LOCAL_CRATE};
116 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
117 use rustc_hir::itemlikevisit::ItemLikeVisitor;
118 use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath};
119 use rustc_index::vec::Idx;
120 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
121 use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
122 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
123 use rustc_infer::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
124 use rustc_infer::infer::{self, InferCtxt, InferOk, InferResult, TyCtxtInferExt};
125 use rustc_session::config::{self, EntryFnType};
126 use rustc_session::lint;
127 use rustc_session::parse::feature_err;
128 use rustc_session::Session;
129 use rustc_span::hygiene::DesugaringKind;
130 use rustc_span::source_map::{original_sp, DUMMY_SP};
131 use rustc_span::symbol::{kw, sym, Ident};
132 use rustc_span::{self, BytePos, MultiSpan, Span};
133 use rustc_target::spec::abi::Abi;
134 use rustc_trait_selection::infer::InferCtxtExt as _;
135 use rustc_trait_selection::opaque_types::{InferCtxtExt as _, OpaqueTypeDecl};
136 use rustc_trait_selection::traits::error_reporting::recursive_type_with_infinite_size_error;
137 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
138 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
139 use rustc_trait_selection::traits::{
140 self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt,
143 use std::cell::{Cell, Ref, RefCell, RefMut};
145 use std::collections::hash_map::Entry;
147 use std::mem::replace;
148 use std::ops::{self, Deref};
151 use crate::require_c_abi_if_c_variadic;
152 use crate::util::common::{indenter, ErrorReported};
153 use crate::TypeAndSubsts;
155 use self::autoderef::Autoderef;
156 use self::callee::DeferredCallResolution;
157 use self::coercion::{CoerceMany, DynamicCoerceMany};
158 use self::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
159 use self::method::{MethodCallee, SelfSource};
160 pub use self::Expectation::*;
161 use self::TupleArgumentsFlag::*;
164 macro_rules! type_error_struct {
165 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
166 if $typ.references_error() {
167 $session.diagnostic().struct_dummy()
169 rustc_errors::struct_span_err!($session, $span, $code, $($message)*)
174 /// The type of a local binding, including the revealed type for anon types.
175 #[derive(Copy, Clone, Debug)]
176 pub struct LocalTy<'tcx> {
178 revealed_ty: Ty<'tcx>,
181 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
182 #[derive(Copy, Clone)]
183 struct MaybeInProgressTables<'a, 'tcx> {
184 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
187 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
188 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
189 match self.maybe_tables {
190 Some(tables) => tables.borrow(),
191 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables"),
195 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
196 match self.maybe_tables {
197 Some(tables) => tables.borrow_mut(),
198 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables"),
203 /// Closures defined within the function. For example:
206 /// bar(move|| { ... })
209 /// Here, the function `foo()` and the closure passed to
210 /// `bar()` will each have their own `FnCtxt`, but they will
211 /// share the inherited fields.
212 pub struct Inherited<'a, 'tcx> {
213 infcx: InferCtxt<'a, 'tcx>,
215 tables: MaybeInProgressTables<'a, 'tcx>,
217 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
219 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
221 // Some additional `Sized` obligations badly affect type inference.
222 // These obligations are added in a later stage of typeck.
223 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
225 // When we process a call like `c()` where `c` is a closure type,
226 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
227 // `FnOnce` closure. In that case, we defer full resolution of the
228 // call until upvar inference can kick in and make the
229 // decision. We keep these deferred resolutions grouped by the
230 // def-id of the closure, so that once we decide, we can easily go
231 // back and process them.
232 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
234 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
236 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
238 // Opaque types found in explicit return types and their
239 // associated fresh inference variable. Writeback resolves these
240 // variables to get the concrete type, which can be used to
241 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
242 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
244 /// A map from inference variables created from opaque
245 /// type instantiations (`ty::Infer`) to the actual opaque
246 /// type (`ty::Opaque`). Used during fallback to map unconstrained
247 /// opaque type inference variables to their corresponding
249 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
251 /// Each type parameter has an implicit region bound that
252 /// indicates it must outlive at least the function body (the user
253 /// may specify stronger requirements). This field indicates the
254 /// region of the callee. If it is `None`, then the parameter
255 /// environment is for an item or something where the "callee" is
257 implicit_region_bound: Option<ty::Region<'tcx>>,
259 body_id: Option<hir::BodyId>,
262 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
263 type Target = InferCtxt<'a, 'tcx>;
264 fn deref(&self) -> &Self::Target {
269 /// When type-checking an expression, we propagate downward
270 /// whatever type hint we are able in the form of an `Expectation`.
271 #[derive(Copy, Clone, Debug)]
272 pub enum Expectation<'tcx> {
273 /// We know nothing about what type this expression should have.
276 /// This expression should have the type given (or some subtype).
277 ExpectHasType(Ty<'tcx>),
279 /// This expression will be cast to the `Ty`.
280 ExpectCastableToType(Ty<'tcx>),
282 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
283 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
284 ExpectRvalueLikeUnsized(Ty<'tcx>),
287 impl<'a, 'tcx> Expectation<'tcx> {
288 // Disregard "castable to" expectations because they
289 // can lead us astray. Consider for example `if cond
290 // {22} else {c} as u8` -- if we propagate the
291 // "castable to u8" constraint to 22, it will pick the
292 // type 22u8, which is overly constrained (c might not
293 // be a u8). In effect, the problem is that the
294 // "castable to" expectation is not the tightest thing
295 // we can say, so we want to drop it in this case.
296 // The tightest thing we can say is "must unify with
297 // else branch". Note that in the case of a "has type"
298 // constraint, this limitation does not hold.
300 // If the expected type is just a type variable, then don't use
301 // an expected type. Otherwise, we might write parts of the type
302 // when checking the 'then' block which are incompatible with the
304 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
306 ExpectHasType(ety) => {
307 let ety = fcx.shallow_resolve(ety);
308 if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
310 ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
315 /// Provides an expectation for an rvalue expression given an *optional*
316 /// hint, which is not required for type safety (the resulting type might
317 /// be checked higher up, as is the case with `&expr` and `box expr`), but
318 /// is useful in determining the concrete type.
320 /// The primary use case is where the expected type is a fat pointer,
321 /// like `&[isize]`. For example, consider the following statement:
323 /// let x: &[isize] = &[1, 2, 3];
325 /// In this case, the expected type for the `&[1, 2, 3]` expression is
326 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
327 /// expectation `ExpectHasType([isize])`, that would be too strong --
328 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
329 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
330 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
331 /// which still is useful, because it informs integer literals and the like.
332 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
333 /// for examples of where this comes up,.
334 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
335 match fcx.tcx.struct_tail_without_normalization(ty).kind {
336 ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
337 _ => ExpectHasType(ty),
341 // Resolves `expected` by a single level if it is a variable. If
342 // there is no expected type or resolution is not possible (e.g.,
343 // no constraints yet present), just returns `None`.
344 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
346 NoExpectation => NoExpectation,
347 ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
348 ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
349 ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
353 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
354 match self.resolve(fcx) {
355 NoExpectation => None,
356 ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
360 /// It sometimes happens that we want to turn an expectation into
361 /// a **hard constraint** (i.e., something that must be satisfied
362 /// for the program to type-check). `only_has_type` will return
363 /// such a constraint, if it exists.
364 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
365 match self.resolve(fcx) {
366 ExpectHasType(ty) => Some(ty),
367 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
371 /// Like `only_has_type`, but instead of returning `None` if no
372 /// hard constraint exists, creates a fresh type variable.
373 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
374 self.only_has_type(fcx).unwrap_or_else(|| {
375 fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
380 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
387 fn maybe_mut_place(m: hir::Mutability) -> Self {
389 hir::Mutability::Mut => Needs::MutPlace,
390 hir::Mutability::Not => 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 use hir::BlockCheckMode;
410 match self.unsafety {
411 // If this unsafe, then if the outer function was already marked as
412 // unsafe we shouldn't attribute the unsafe'ness to the block. This
413 // way the block can be warned about instead of ignoring this
414 // extraneous block (functions are never warned about).
415 hir::Unsafety::Unsafe if self.from_fn => *self,
418 let (unsafety, def, count) = match blk.rules {
419 BlockCheckMode::PushUnsafeBlock(..) => {
420 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
422 BlockCheckMode::PopUnsafeBlock(..) => {
423 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
425 BlockCheckMode::UnsafeBlock(..) => {
426 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
428 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
430 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
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 message
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 combining `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 {
506 Diverges::Always { span, custom_note: None }
509 fn is_always(self) -> bool {
510 // Enum comparison ignores the
511 // contents of fields, so we just
512 // fill them in with garbage here.
513 self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
517 pub struct BreakableCtxt<'tcx> {
520 // this is `null` for loops where break with a value is illegal,
521 // such as `while`, `for`, and `while let`
522 coerce: Option<DynamicCoerceMany<'tcx>>,
525 pub struct EnclosingBreakables<'tcx> {
526 stack: Vec<BreakableCtxt<'tcx>>,
527 by_id: HirIdMap<usize>,
530 impl<'tcx> EnclosingBreakables<'tcx> {
531 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
532 self.opt_find_breakable(target_id).unwrap_or_else(|| {
533 bug!("could not find enclosing breakable with id {}", target_id);
537 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
538 match self.by_id.get(&target_id) {
539 Some(ix) => Some(&mut self.stack[*ix]),
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 /// If `Some`, this stores coercion information for returned
565 /// expressions. If `None`, this is in a context where return is
566 /// inappropriate, such as a const expression.
568 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
569 /// can track all the return expressions and then use them to
570 /// compute a useful coercion from the set, similar to a match
571 /// expression or other branching context. You can use methods
572 /// like `expected_ty` to access the declared return type (if
574 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
576 /// First span of a return site that we find. Used in error messages.
577 ret_coercion_span: RefCell<Option<Span>>,
579 resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>,
581 ps: RefCell<UnsafetyState>,
583 /// Whether the last checked node generates a divergence (e.g.,
584 /// `return` will set this to `Always`). In general, when entering
585 /// an expression or other node in the tree, the initial value
586 /// indicates whether prior parts of the containing expression may
587 /// have diverged. It is then typically set to `Maybe` (and the
588 /// old value remembered) for processing the subparts of the
589 /// current expression. As each subpart is processed, they may set
590 /// the flag to `Always`, etc. Finally, at the end, we take the
591 /// result and "union" it with the original value, so that when we
592 /// return the flag indicates if any subpart of the parent
593 /// expression (up to and including this part) has diverged. So,
594 /// if you read it after evaluating a subexpression `X`, the value
595 /// you get indicates whether any subexpression that was
596 /// evaluating up to and including `X` diverged.
598 /// We currently use this flag only for diagnostic purposes:
600 /// - To warn about unreachable code: if, after processing a
601 /// sub-expression but before we have applied the effects of the
602 /// current node, we see that the flag is set to `Always`, we
603 /// can issue a warning. This corresponds to something like
604 /// `foo(return)`; we warn on the `foo()` expression. (We then
605 /// update the flag to `WarnedAlways` to suppress duplicate
606 /// reports.) Similarly, if we traverse to a fresh statement (or
607 /// tail expression) from a `Always` setting, we will issue a
608 /// warning. This corresponds to something like `{return;
609 /// foo();}` or `{return; 22}`, where we would warn on the
612 /// An expression represents dead code if, after checking it,
613 /// the diverges flag is set to something other than `Maybe`.
614 diverges: Cell<Diverges>,
616 /// Whether any child nodes have any type errors.
617 has_errors: Cell<bool>,
619 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
621 inh: &'a Inherited<'a, 'tcx>,
624 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
625 type Target = Inherited<'a, 'tcx>;
626 fn deref(&self) -> &Self::Target {
631 /// Helper type of a temporary returned by `Inherited::build(...)`.
632 /// Necessary because we can't write the following bound:
633 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
634 pub struct InheritedBuilder<'tcx> {
635 infcx: infer::InferCtxtBuilder<'tcx>,
639 impl Inherited<'_, 'tcx> {
640 pub fn build(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> InheritedBuilder<'tcx> {
641 let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
644 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_owner),
650 impl<'tcx> InheritedBuilder<'tcx> {
651 fn enter<F, R>(&mut self, f: F) -> R
653 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
655 let def_id = self.def_id;
656 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
660 impl Inherited<'a, 'tcx> {
661 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
663 let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
664 let body_id = tcx.hir().maybe_body_owned_by(item_id);
665 let implicit_region_bound = body_id.map(|body_id| {
666 let body = tcx.hir().body(body_id);
667 tcx.mk_region(ty::ReScope(region::Scope {
668 id: body.value.hir_id.local_id,
669 data: region::ScopeData::CallSite,
674 tables: MaybeInProgressTables { maybe_tables: infcx.in_progress_tables },
676 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
677 locals: RefCell::new(Default::default()),
678 deferred_sized_obligations: RefCell::new(Vec::new()),
679 deferred_call_resolutions: RefCell::new(Default::default()),
680 deferred_cast_checks: RefCell::new(Vec::new()),
681 deferred_generator_interiors: RefCell::new(Vec::new()),
682 opaque_types: RefCell::new(Default::default()),
683 opaque_types_vars: RefCell::new(Default::default()),
684 implicit_region_bound,
689 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
690 debug!("register_predicate({:?})", obligation);
691 if obligation.has_escaping_bound_vars() {
692 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
694 self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
697 fn register_predicates<I>(&self, obligations: I)
699 I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
701 for obligation in obligations {
702 self.register_predicate(obligation);
706 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
707 self.register_predicates(infer_ok.obligations);
711 fn normalize_associated_types_in<T>(
715 param_env: ty::ParamEnv<'tcx>,
719 T: TypeFoldable<'tcx>,
721 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
722 self.register_infer_ok_obligations(ok)
726 struct CheckItemTypesVisitor<'tcx> {
730 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
731 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
732 check_item_type(self.tcx, i);
734 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
735 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
738 pub fn check_wf_new(tcx: TyCtxt<'_>) {
739 let visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
740 tcx.hir().krate().par_visit_all_item_likes(&visit);
743 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
744 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
747 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
748 debug_assert!(crate_num == LOCAL_CRATE);
749 tcx.par_body_owners(|body_owner_def_id| {
750 tcx.ensure().typeck_tables_of(body_owner_def_id);
754 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
755 wfcheck::check_item_well_formed(tcx, def_id);
758 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
759 wfcheck::check_trait_item(tcx, def_id);
762 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
763 wfcheck::check_impl_item(tcx, def_id);
766 pub fn provide(providers: &mut Providers<'_>) {
767 method::provide(providers);
768 *providers = Providers {
771 diagnostic_only_typeck_tables_of,
775 check_item_well_formed,
776 check_trait_item_well_formed,
777 check_impl_item_well_formed,
778 check_mod_item_types,
783 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
784 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
787 /// If this `DefId` is a "primary tables entry", returns
788 /// `Some((body_id, header, decl))` with information about
789 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
792 /// If this function returns `Some`, then `typeck_tables(def_id)` will
793 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
794 /// may not succeed. In some cases where this function returns `None`
795 /// (notably closures), `typeck_tables(def_id)` would wind up
796 /// redirecting to the owning function.
800 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
801 match tcx.hir().get(id) {
802 Node::Item(item) => match item.kind {
803 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
804 Some((body, Some(ty), None, None))
806 hir::ItemKind::Fn(ref sig, .., body) => {
807 Some((body, None, Some(&sig.header), Some(&sig.decl)))
811 Node::TraitItem(item) => match item.kind {
812 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
813 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
814 Some((body, None, Some(&sig.header), Some(&sig.decl)))
818 Node::ImplItem(item) => match item.kind {
819 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
820 hir::ImplItemKind::Fn(ref sig, body) => {
821 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 if let Some(id) = tcx.hir().as_local_hir_id(def_id) {
839 primary_body_of(tcx, id).is_some()
845 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
846 &*tcx.typeck_tables_of(def_id).used_trait_imports
849 /// Inspects the substs of opaque types, replacing any inference variables
850 /// with proper generic parameter from the identity substs.
852 /// This is run after we normalize the function signature, to fix any inference
853 /// variables introduced by the projection of associated types. This ensures that
854 /// any opaque types used in the signature continue to refer to generic parameters,
855 /// allowing them to be considered for defining uses in the function body
857 /// For example, consider this code.
862 /// fn use_it(self) -> Self::MyItem
864 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
865 /// type MyItem = impl Iterator<Item = I>;
866 /// fn use_it(self) -> Self::MyItem {
872 /// When we normalize the signature of `use_it` from the impl block,
873 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
874 /// However, this projection result may contain inference variables, due
875 /// to the way that projection works. We didn't have any inference variables
876 /// in the signature to begin with - leaving them in will cause us to incorrectly
877 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
878 /// variables back to the actual generic parameters, we will correctly see that
879 /// we have a defining use of `MyItem`
880 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
882 T: TypeFoldable<'tcx>,
884 struct FixupFolder<'tcx> {
888 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
889 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
893 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
895 ty::Opaque(def_id, substs) => {
896 debug!("fixup_opaque_types: found type {:?}", ty);
897 // Here, we replace any inference variables that occur within
898 // the substs of an opaque type. By definition, any type occurring
899 // in the substs has a corresponding generic parameter, which is what
900 // we replace it with.
901 // This replacement is only run on the function signature, so any
902 // inference variables that we come across must be the rust of projection
903 // (there's no other way for a user to get inference variables into
904 // a function signature).
905 if ty.needs_infer() {
906 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
907 let old_param = substs[param.index as usize];
908 match old_param.unpack() {
909 GenericArgKind::Type(old_ty) => {
910 if let ty::Infer(_) = old_ty.kind {
911 // Replace inference type with a generic parameter
912 self.tcx.mk_param_from_def(param)
914 old_param.fold_with(self)
917 GenericArgKind::Const(old_const) => {
918 if let ty::ConstKind::Infer(_) = old_const.val {
919 // This should never happen - we currently do not support
920 // 'const projections', e.g.:
921 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
922 // which should be the only way for us to end up with a const inference
923 // variable after projection. If Rust ever gains support for this kind
924 // of projection, this should *probably* be changed to
925 // `self.tcx.mk_param_from_def(param)`
927 "Found infer const: `{:?}` in opaque type: {:?}",
932 old_param.fold_with(self)
935 GenericArgKind::Lifetime(old_region) => {
936 if let RegionKind::ReVar(_) = old_region {
937 self.tcx.mk_param_from_def(param)
939 old_param.fold_with(self)
944 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
945 debug!("fixup_opaque_types: new type: {:?}", new_ty);
951 _ => ty.super_fold_with(self),
956 debug!("fixup_opaque_types({:?})", val);
957 val.fold_with(&mut FixupFolder { tcx })
960 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &ty::TypeckTables<'tcx> {
961 let fallback = move || tcx.type_of(def_id);
962 typeck_tables_of_with_fallback(tcx, def_id, fallback)
965 /// Used only to get `TypeckTables` for type inference during error recovery.
966 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
967 fn diagnostic_only_typeck_tables_of<'tcx>(
970 ) -> &ty::TypeckTables<'tcx> {
971 assert!(def_id.is_local());
972 let fallback = move || {
973 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id).unwrap());
974 tcx.sess.delay_span_bug(span, "diagnostic only typeck table used");
977 typeck_tables_of_with_fallback(tcx, def_id, fallback)
980 fn typeck_tables_of_with_fallback<'tcx>(
983 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
984 ) -> &'tcx ty::TypeckTables<'tcx> {
985 // Closures' tables come from their outermost function,
986 // as they are part of the same "inference environment".
987 let outer_def_id = tcx.closure_base_def_id(def_id);
988 if outer_def_id != def_id {
989 return tcx.typeck_tables_of(outer_def_id);
992 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
993 let span = tcx.hir().span(id);
995 // Figure out what primary body this item has.
996 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
997 span_bug!(span, "can't type-check body of {:?}", def_id);
999 let body = tcx.hir().body(body_id);
1001 let tables = Inherited::build(tcx, def_id.expect_local()).enter(|inh| {
1002 let param_env = tcx.param_env(def_id);
1003 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1004 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1005 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1006 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl, &[], None)
1011 check_abi(tcx, span, fn_sig.abi());
1013 // Compute the fty from point of view of inside the fn.
1014 let fn_sig = tcx.liberate_late_bound_regions(def_id, &fn_sig);
1015 let fn_sig = inh.normalize_associated_types_in(
1022 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1024 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1027 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1028 let expected_type = body_ty
1029 .and_then(|ty| match ty.kind {
1030 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1033 .unwrap_or_else(fallback);
1034 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1035 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1037 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1038 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1043 // Gather locals in statics (because of block expressions).
1044 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1046 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1048 fcx.write_ty(id, revealed_ty);
1053 // All type checking constraints were added, try to fallback unsolved variables.
1054 fcx.select_obligations_where_possible(false, |_| {});
1055 let mut fallback_has_occurred = false;
1057 // We do fallback in two passes, to try to generate
1058 // better error messages.
1059 // The first time, we do *not* replace opaque types.
1060 for ty in &fcx.unsolved_variables() {
1061 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1063 // We now see if we can make progress. This might
1064 // cause us to unify inference variables for opaque types,
1065 // since we may have unified some other type variables
1066 // during the first phase of fallback.
1067 // This means that we only replace inference variables with their underlying
1068 // opaque types as a last resort.
1070 // In code like this:
1073 // type MyType = impl Copy;
1074 // fn produce() -> MyType { true }
1075 // fn bad_produce() -> MyType { panic!() }
1078 // we want to unify the opaque inference variable in `bad_produce`
1079 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1080 // This will produce a nice error message about conflicting concrete
1081 // types for `MyType`.
1083 // If we had tried to fallback the opaque inference variable to `MyType`,
1084 // we will generate a confusing type-check error that does not explicitly
1085 // refer to opaque types.
1086 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1088 // We now run fallback again, but this time we allow it to replace
1089 // unconstrained opaque type variables, in addition to performing
1090 // other kinds of fallback.
1091 for ty in &fcx.unsolved_variables() {
1092 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1095 // See if we can make any more progress.
1096 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1098 // Even though coercion casts provide type hints, we check casts after fallback for
1099 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1102 // Closure and generator analysis may run after fallback
1103 // because they don't constrain other type variables.
1104 fcx.closure_analyze(body);
1105 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1106 fcx.resolve_generator_interiors(def_id);
1108 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1109 let ty = fcx.normalize_ty(span, ty);
1110 fcx.require_type_is_sized(ty, span, code);
1113 fcx.select_all_obligations_or_error();
1115 if fn_decl.is_some() {
1116 fcx.regionck_fn(id, body);
1118 fcx.regionck_expr(body);
1121 fcx.resolve_type_vars_in_body(body)
1124 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1125 // it will need to hold.
1126 assert_eq!(tables.hir_owner, Some(id.owner));
1131 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1132 if !tcx.sess.target.target.is_abi_supported(abi) {
1137 "The ABI `{}` is not supported for the current target",
1144 struct GatherLocalsVisitor<'a, 'tcx> {
1145 fcx: &'a FnCtxt<'a, 'tcx>,
1146 parent_id: hir::HirId,
1149 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1150 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1153 // infer the variable's type
1154 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1155 kind: TypeVariableOriginKind::TypeInference,
1161 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1165 // take type that the user specified
1166 self.fcx.locals.borrow_mut().insert(nid, typ);
1173 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1174 type Map = intravisit::ErasedMap<'tcx>;
1176 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
1177 NestedVisitorMap::None
1180 // Add explicitly-declared locals.
1181 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1182 let local_ty = match local.ty {
1184 let o_ty = self.fcx.to_ty(&ty);
1186 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1187 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1196 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1198 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1199 ty.hir_id, o_ty, revealed_ty, c_ty
1201 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1203 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1207 self.assign(local.span, local.hir_id, local_ty);
1210 "local variable {:?} is assigned type {}",
1212 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&local.hir_id).unwrap().decl_ty)
1214 intravisit::walk_local(self, local);
1217 // Add pattern bindings.
1218 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1219 if let PatKind::Binding(_, _, ident, _) = p.kind {
1220 let var_ty = self.assign(p.span, p.hir_id, None);
1222 if !self.fcx.tcx.features().unsized_locals {
1223 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1227 "pattern binding {} is assigned to {} with type {:?}",
1229 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&p.hir_id).unwrap().decl_ty),
1233 intravisit::walk_pat(self, p);
1236 // Don't descend into the bodies of nested closures
1239 _: intravisit::FnKind<'tcx>,
1240 _: &'tcx hir::FnDecl<'tcx>,
1248 /// When `check_fn` is invoked on a generator (i.e., a body that
1249 /// includes yield), it returns back some information about the yield
1251 struct GeneratorTypes<'tcx> {
1252 /// Type of generator argument / values returned by `yield`.
1253 resume_ty: Ty<'tcx>,
1255 /// Type of value that is yielded.
1258 /// Types that are captured (see `GeneratorInterior` for more).
1261 /// Indicates if the generator is movable or static (immovable).
1262 movability: hir::Movability,
1265 /// Helper used for fns and closures. Does the grungy work of checking a function
1266 /// body and returns the function context used for that purpose, since in the case of a fn item
1267 /// there is still a bit more to do.
1270 /// * inherited: other fields inherited from the enclosing fn (if any)
1271 fn check_fn<'a, 'tcx>(
1272 inherited: &'a Inherited<'a, 'tcx>,
1273 param_env: ty::ParamEnv<'tcx>,
1274 fn_sig: ty::FnSig<'tcx>,
1275 decl: &'tcx hir::FnDecl<'tcx>,
1277 body: &'tcx hir::Body<'tcx>,
1278 can_be_generator: Option<hir::Movability>,
1279 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1280 let mut fn_sig = fn_sig;
1282 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1284 // Create the function context. This is either derived from scratch or,
1285 // in the case of closures, based on the outer context.
1286 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1287 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1290 let sess = tcx.sess;
1291 let hir = tcx.hir();
1293 let declared_ret_ty = fn_sig.output();
1294 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1295 let revealed_ret_ty =
1296 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1297 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1298 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1299 fn_sig = tcx.mk_fn_sig(
1300 fn_sig.inputs().iter().cloned(),
1307 let span = body.value.span;
1309 fn_maybe_err(tcx, span, fn_sig.abi);
1311 if body.generator_kind.is_some() && can_be_generator.is_some() {
1313 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1314 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1316 // Resume type defaults to `()` if the generator has no argument.
1317 let resume_ty = fn_sig.inputs().get(0).copied().unwrap_or_else(|| tcx.mk_unit());
1319 fcx.resume_yield_tys = Some((resume_ty, yield_ty));
1322 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id));
1323 let outer_hir_id = hir.as_local_hir_id(outer_def_id).unwrap();
1324 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1326 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1327 // (as it's created inside the body itself, not passed in from outside).
1328 let maybe_va_list = if fn_sig.c_variadic {
1329 let va_list_did = tcx.require_lang_item(
1330 lang_items::VaListTypeLangItem,
1331 Some(body.params.last().unwrap().span),
1333 let region = tcx.mk_region(ty::ReScope(region::Scope {
1334 id: body.value.hir_id.local_id,
1335 data: region::ScopeData::CallSite,
1338 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1343 // Add formal parameters.
1344 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1345 let inputs_fn = fn_sig.inputs().iter().copied();
1346 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1347 // Check the pattern.
1348 fcx.check_pat_top(¶m.pat, param_ty, try { inputs_hir?.get(idx)?.span }, false);
1350 // Check that argument is Sized.
1351 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1352 // for simple cases like `fn foo(x: Trait)`,
1353 // where we would error once on the parameter as a whole, and once on the binding `x`.
1354 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1355 fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType);
1358 fcx.write_ty(param.hir_id, param_ty);
1361 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1363 fcx.check_return_expr(&body.value);
1365 // We insert the deferred_generator_interiors entry after visiting the body.
1366 // This ensures that all nested generators appear before the entry of this generator.
1367 // resolve_generator_interiors relies on this property.
1368 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1370 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1371 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1373 let (resume_ty, yield_ty) = fcx.resume_yield_tys.unwrap();
1374 Some(GeneratorTypes {
1378 movability: can_be_generator.unwrap(),
1384 // Finalize the return check by taking the LUB of the return types
1385 // we saw and assigning it to the expected return type. This isn't
1386 // really expected to fail, since the coercions would have failed
1387 // earlier when trying to find a LUB.
1389 // However, the behavior around `!` is sort of complex. In the
1390 // event that the `actual_return_ty` comes back as `!`, that
1391 // indicates that the fn either does not return or "returns" only
1392 // values of type `!`. In this case, if there is an expected
1393 // return type that is *not* `!`, that should be ok. But if the
1394 // return type is being inferred, we want to "fallback" to `!`:
1396 // let x = move || panic!();
1398 // To allow for that, I am creating a type variable with diverging
1399 // fallback. This was deemed ever so slightly better than unifying
1400 // the return value with `!` because it allows for the caller to
1401 // make more assumptions about the return type (e.g., they could do
1403 // let y: Option<u32> = Some(x());
1405 // which would then cause this return type to become `u32`, not
1407 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1408 let mut actual_return_ty = coercion.complete(&fcx);
1409 if actual_return_ty.is_never() {
1410 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1411 kind: TypeVariableOriginKind::DivergingFn,
1415 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1417 // Check that the main return type implements the termination trait.
1418 if let Some(term_id) = tcx.lang_items().termination() {
1419 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1420 let main_id = hir.as_local_hir_id(def_id).unwrap();
1421 if main_id == fn_id {
1422 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1423 let trait_ref = ty::TraitRef::new(term_id, substs);
1424 let return_ty_span = decl.output.span();
1425 let cause = traits::ObligationCause::new(
1428 ObligationCauseCode::MainFunctionType,
1431 inherited.register_predicate(traits::Obligation::new(
1434 trait_ref.without_const().to_predicate(),
1440 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1441 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1442 if panic_impl_did == hir.local_def_id(fn_id) {
1443 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1444 if declared_ret_ty.kind != ty::Never {
1445 sess.span_err(decl.output.span(), "return type should be `!`");
1448 let inputs = fn_sig.inputs();
1449 let span = hir.span(fn_id);
1450 if inputs.len() == 1 {
1451 let arg_is_panic_info = match inputs[0].kind {
1452 ty::Ref(region, ty, mutbl) => match ty.kind {
1453 ty::Adt(ref adt, _) => {
1454 adt.did == panic_info_did
1455 && mutbl == hir::Mutability::Not
1456 && *region != RegionKind::ReStatic
1463 if !arg_is_panic_info {
1464 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1467 if let Node::Item(item) = hir.get(fn_id) {
1468 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1469 if !generics.params.is_empty() {
1470 sess.span_err(span, "should have no type parameters");
1475 let span = sess.source_map().def_span(span);
1476 sess.span_err(span, "function should have one argument");
1479 sess.err("language item required, but not found: `panic_info`");
1484 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1485 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1486 if alloc_error_handler_did == hir.local_def_id(fn_id) {
1487 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1488 if declared_ret_ty.kind != ty::Never {
1489 sess.span_err(decl.output.span(), "return type should be `!`");
1492 let inputs = fn_sig.inputs();
1493 let span = hir.span(fn_id);
1494 if inputs.len() == 1 {
1495 let arg_is_alloc_layout = match inputs[0].kind {
1496 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1500 if !arg_is_alloc_layout {
1501 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1504 if let Node::Item(item) = hir.get(fn_id) {
1505 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1506 if !generics.params.is_empty() {
1509 "`#[alloc_error_handler]` function should have no type \
1516 let span = sess.source_map().def_span(span);
1517 sess.span_err(span, "function should have one argument");
1520 sess.err("language item required, but not found: `alloc_layout`");
1528 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1529 let def_id = tcx.hir().local_def_id(id);
1530 let def = tcx.adt_def(def_id);
1531 def.destructor(tcx); // force the destructor to be evaluated
1532 check_representable(tcx, span, def_id);
1534 if def.repr.simd() {
1535 check_simd(tcx, span, def_id);
1538 check_transparent(tcx, span, def_id);
1539 check_packed(tcx, span, def_id);
1542 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1543 let def_id = tcx.hir().local_def_id(id);
1544 let def = tcx.adt_def(def_id);
1545 def.destructor(tcx); // force the destructor to be evaluated
1546 check_representable(tcx, span, def_id);
1547 check_transparent(tcx, span, def_id);
1548 check_union_fields(tcx, span, def_id);
1549 check_packed(tcx, span, def_id);
1552 /// When the `#![feature(untagged_unions)]` gate is active,
1553 /// check that the fields of the `union` does not contain fields that need dropping.
1554 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1555 let item_type = tcx.type_of(item_def_id);
1556 if let ty::Adt(def, substs) = item_type.kind {
1557 assert!(def.is_union());
1558 let fields = &def.non_enum_variant().fields;
1559 let param_env = tcx.param_env(item_def_id);
1560 for field in fields {
1561 let field_ty = field.ty(tcx, substs);
1562 // We are currently checking the type this field came from, so it must be local.
1563 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1564 if field_ty.needs_drop(tcx, param_env) {
1569 "unions may not contain fields that need dropping"
1571 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1577 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1582 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1583 /// projections that would result in "inheriting lifetimes".
1584 fn check_opaque<'tcx>(
1587 substs: SubstsRef<'tcx>,
1589 origin: &hir::OpaqueTyOrigin,
1591 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1592 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1595 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1596 /// in "inheriting lifetimes".
1597 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: Span) {
1599 tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1601 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1606 struct ProhibitOpaqueVisitor<'tcx> {
1607 opaque_identity_ty: Ty<'tcx>,
1608 generics: &'tcx ty::Generics,
1611 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1612 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1613 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1614 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1617 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1618 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1619 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1620 return *index < self.generics.parent_count as u32;
1623 r.super_visit_with(self)
1627 let prohibit_opaque = match item.kind {
1628 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. })
1629 | ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1630 let mut visitor = ProhibitOpaqueVisitor {
1631 opaque_identity_ty: tcx
1632 .mk_opaque(def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1633 generics: tcx.generics_of(def_id),
1635 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1637 tcx.predicates_of(def_id)
1640 .any(|(predicate, _)| predicate.visit_with(&mut visitor))
1645 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1646 if prohibit_opaque {
1647 let is_async = match item.kind {
1648 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1649 hir::OpaqueTyOrigin::AsyncFn => true,
1652 _ => unreachable!(),
1655 tcx.sess.span_err(span, &format!(
1656 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1658 if is_async { "async fn" } else { "impl Trait" },
1663 /// Checks that an opaque type does not contain cycles.
1664 fn check_opaque_for_cycles<'tcx>(
1667 substs: SubstsRef<'tcx>,
1669 origin: &hir::OpaqueTyOrigin,
1671 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1672 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1673 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",)
1674 .span_label(span, "recursive `async fn`")
1675 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
1679 struct_span_err!(tcx.sess, span, E0720, "opaque type expands to a recursive type",);
1680 err.span_label(span, "expands to a recursive type");
1681 if let ty::Opaque(..) = partially_expanded_type.kind {
1682 err.note("type resolves to itself");
1684 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1691 // Forbid defining intrinsics in Rust code,
1692 // as they must always be defined by the compiler.
1693 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1694 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1695 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1699 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1701 "check_item_type(it.hir_id={}, it.name={})",
1703 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1705 let _indenter = indenter();
1707 // Consts can play a role in type-checking, so they are included here.
1708 hir::ItemKind::Static(..) => {
1709 let def_id = tcx.hir().local_def_id(it.hir_id);
1710 tcx.typeck_tables_of(def_id);
1711 maybe_check_static_with_link_section(tcx, def_id, it.span);
1713 hir::ItemKind::Const(..) => {
1714 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1716 hir::ItemKind::Enum(ref enum_definition, _) => {
1717 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1719 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1720 hir::ItemKind::Impl { ref items, .. } => {
1721 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1722 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1723 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1724 check_impl_items_against_trait(tcx, it.span, impl_def_id, impl_trait_ref, items);
1725 let trait_def_id = impl_trait_ref.def_id;
1726 check_on_unimplemented(tcx, trait_def_id, it);
1729 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1730 let def_id = tcx.hir().local_def_id(it.hir_id);
1731 check_on_unimplemented(tcx, def_id, it);
1733 for item in items.iter() {
1734 let item = tcx.hir().trait_item(item.id);
1735 if let hir::TraitItemKind::Fn(sig, _) = &item.kind {
1736 let abi = sig.header.abi;
1737 fn_maybe_err(tcx, item.ident.span, abi);
1741 hir::ItemKind::Struct(..) => {
1742 check_struct(tcx, it.hir_id, it.span);
1744 hir::ItemKind::Union(..) => {
1745 check_union(tcx, it.hir_id, it.span);
1747 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1748 let def_id = tcx.hir().local_def_id(it.hir_id);
1750 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1751 check_opaque(tcx, def_id, substs, it.span, &origin);
1753 hir::ItemKind::TyAlias(..) => {
1754 let def_id = tcx.hir().local_def_id(it.hir_id);
1755 let pty_ty = tcx.type_of(def_id);
1756 let generics = tcx.generics_of(def_id);
1757 check_bounds_are_used(tcx, &generics, pty_ty);
1759 hir::ItemKind::ForeignMod(ref m) => {
1760 check_abi(tcx, it.span, m.abi);
1762 if m.abi == Abi::RustIntrinsic {
1763 for item in m.items {
1764 intrinsic::check_intrinsic_type(tcx, item);
1766 } else if m.abi == Abi::PlatformIntrinsic {
1767 for item in m.items {
1768 intrinsic::check_platform_intrinsic_type(tcx, item);
1771 for item in m.items {
1772 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1773 let own_counts = generics.own_counts();
1774 if generics.params.len() - own_counts.lifetimes != 0 {
1775 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1776 (_, 0) => ("type", "types", Some("u32")),
1777 // We don't specify an example value, because we can't generate
1778 // a valid value for any type.
1779 (0, _) => ("const", "consts", None),
1780 _ => ("type or const", "types or consts", None),
1786 "foreign items may not have {} parameters",
1789 .span_label(item.span, &format!("can't have {} parameters", kinds))
1791 // FIXME: once we start storing spans for type arguments, turn this
1792 // into a suggestion.
1794 "replace the {} parameters with concrete {}{}",
1797 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1803 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1804 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1809 _ => { /* nothing to do */ }
1813 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1814 // Only restricted on wasm32 target for now
1815 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1819 // If `#[link_section]` is missing, then nothing to verify
1820 let attrs = tcx.codegen_fn_attrs(id);
1821 if attrs.link_section.is_none() {
1825 // For the wasm32 target statics with `#[link_section]` are placed into custom
1826 // sections of the final output file, but this isn't link custom sections of
1827 // other executable formats. Namely we can only embed a list of bytes,
1828 // nothing with pointers to anything else or relocations. If any relocation
1829 // show up, reject them here.
1830 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1831 // the consumer's responsibility to ensure all bytes that have been read
1832 // have defined values.
1833 match tcx.const_eval_poly(id) {
1834 Ok(ConstValue::ByRef { alloc, .. }) => {
1835 if alloc.relocations().len() != 0 {
1836 let msg = "statics with a custom `#[link_section]` must be a \
1837 simple list of bytes on the wasm target with no \
1838 extra levels of indirection such as references";
1839 tcx.sess.span_err(span, msg);
1842 Ok(_) => bug!("Matching on non-ByRef static"),
1847 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1848 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1849 // an error would be reported if this fails.
1850 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1853 fn report_forbidden_specialization(
1855 impl_item: &hir::ImplItem<'_>,
1858 let mut err = struct_span_err!(
1862 "`{}` specializes an item from a parent `impl`, but \
1863 that item is not marked `default`",
1866 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
1868 match tcx.span_of_impl(parent_impl) {
1870 err.span_label(span, "parent `impl` is here");
1872 "to specialize, `{}` in the parent `impl` must be marked `default`",
1877 err.note(&format!("parent implementation is in crate `{}`", cname));
1884 fn check_specialization_validity<'tcx>(
1886 trait_def: &ty::TraitDef,
1887 trait_item: &ty::AssocItem,
1889 impl_item: &hir::ImplItem<'_>,
1891 let kind = match impl_item.kind {
1892 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1893 hir::ImplItemKind::Fn(..) => ty::AssocKind::Method,
1894 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1895 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1898 let ancestors = match trait_def.ancestors(tcx, impl_id) {
1899 Ok(ancestors) => ancestors,
1902 let mut ancestor_impls = ancestors
1904 .filter_map(|parent| {
1905 if parent.is_from_trait() {
1908 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1913 if ancestor_impls.peek().is_none() {
1914 // No parent, nothing to specialize.
1918 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1920 // Parent impl exists, and contains the parent item we're trying to specialize, but
1921 // doesn't mark it `default`.
1922 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1923 Some(Err(parent_impl.def_id()))
1926 // Parent impl contains item and makes it specializable.
1927 Some(_) => Some(Ok(())),
1929 // Parent impl doesn't mention the item. This means it's inherited from the
1930 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1931 // "defaultness" from the grandparent, else they are final.
1933 if traits::impl_is_default(tcx, parent_impl.def_id()) {
1936 Some(Err(parent_impl.def_id()))
1942 // If `opt_result` is `None`, we have only encountered `default impl`s that don't contain the
1943 // item. This is allowed, the item isn't actually getting specialized here.
1944 let result = opt_result.unwrap_or(Ok(()));
1946 if let Err(parent_impl) = result {
1947 report_forbidden_specialization(tcx, impl_item, parent_impl);
1951 fn check_impl_items_against_trait<'tcx>(
1953 full_impl_span: Span,
1955 impl_trait_ref: ty::TraitRef<'tcx>,
1956 impl_item_refs: &[hir::ImplItemRef<'_>],
1958 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1960 // If the trait reference itself is erroneous (so the compilation is going
1961 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1962 // isn't populated for such impls.
1963 if impl_trait_ref.references_error() {
1967 // Locate trait definition and items
1968 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1970 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1972 // Check existing impl methods to see if they are both present in trait
1973 // and compatible with trait signature
1974 for impl_item in impl_items() {
1975 let namespace = impl_item.kind.namespace();
1976 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
1977 let ty_trait_item = tcx
1978 .associated_items(impl_trait_ref.def_id)
1979 .find_by_name_and_namespace(tcx, ty_impl_item.ident, namespace, impl_trait_ref.def_id)
1981 // Not compatible, but needed for the error message
1982 tcx.associated_items(impl_trait_ref.def_id)
1983 .filter_by_name(tcx, ty_impl_item.ident, impl_trait_ref.def_id)
1987 // Check that impl definition matches trait definition
1988 if let Some(ty_trait_item) = ty_trait_item {
1989 match impl_item.kind {
1990 hir::ImplItemKind::Const(..) => {
1991 // Find associated const definition.
1992 if ty_trait_item.kind == ty::AssocKind::Const {
2001 let mut err = struct_span_err!(
2005 "item `{}` is an associated const, \
2006 which doesn't match its trait `{}`",
2008 impl_trait_ref.print_only_trait_path()
2010 err.span_label(impl_item.span, "does not match trait");
2011 // We can only get the spans from local trait definition
2012 // Same for E0324 and E0325
2013 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2014 err.span_label(trait_span, "item in trait");
2019 hir::ImplItemKind::Fn(..) => {
2020 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2021 if ty_trait_item.kind == ty::AssocKind::Method {
2022 compare_impl_method(
2031 let mut err = struct_span_err!(
2035 "item `{}` is an associated method, \
2036 which doesn't match its trait `{}`",
2038 impl_trait_ref.print_only_trait_path()
2040 err.span_label(impl_item.span, "does not match trait");
2041 if let Some(trait_span) = opt_trait_span {
2042 err.span_label(trait_span, "item in trait");
2047 hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {
2048 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2049 if ty_trait_item.kind == ty::AssocKind::Type {
2059 let mut err = struct_span_err!(
2063 "item `{}` is an associated type, \
2064 which doesn't match its trait `{}`",
2066 impl_trait_ref.print_only_trait_path()
2068 err.span_label(impl_item.span, "does not match trait");
2069 if let Some(trait_span) = opt_trait_span {
2070 err.span_label(trait_span, "item in trait");
2077 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2081 // Check for missing items from trait
2082 let mut missing_items = Vec::new();
2083 if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id) {
2084 for trait_item in tcx.associated_items(impl_trait_ref.def_id).in_definition_order() {
2085 let is_implemented = ancestors
2086 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2087 .map(|node_item| !node_item.node.is_from_trait())
2090 if !is_implemented && !traits::impl_is_default(tcx, impl_id) {
2091 if !trait_item.defaultness.has_value() {
2092 missing_items.push(*trait_item);
2098 if !missing_items.is_empty() {
2099 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2103 fn missing_items_err(
2106 missing_items: &[ty::AssocItem],
2107 full_impl_span: Span,
2109 let missing_items_msg = missing_items
2111 .map(|trait_item| trait_item.ident.to_string())
2112 .collect::<Vec<_>>()
2115 let mut err = struct_span_err!(
2119 "not all trait items implemented, missing: `{}`",
2122 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2124 // `Span` before impl block closing brace.
2125 let hi = full_impl_span.hi() - BytePos(1);
2126 // Point at the place right before the closing brace of the relevant `impl` to suggest
2127 // adding the associated item at the end of its body.
2128 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2129 // Obtain the level of indentation ending in `sugg_sp`.
2130 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2131 // Make the whitespace that will make the suggestion have the right indentation.
2132 let padding: String = (0..indentation).map(|_| " ").collect();
2134 for trait_item in missing_items {
2135 let snippet = suggestion_signature(&trait_item, tcx);
2136 let code = format!("{}{}\n{}", padding, snippet, padding);
2137 let msg = format!("implement the missing item: `{}`", snippet);
2138 let appl = Applicability::HasPlaceholders;
2139 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2140 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2141 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2143 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2149 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
2150 fn bounds_from_generic_predicates(
2152 predicates: ty::GenericPredicates<'_>,
2153 ) -> (String, String) {
2154 let mut types: FxHashMap<Ty<'_>, Vec<DefId>> = FxHashMap::default();
2155 let mut projections = vec![];
2156 for (predicate, _) in predicates.predicates {
2157 debug!("predicate {:?}", predicate);
2159 ty::Predicate::Trait(trait_predicate, _) => {
2160 let entry = types.entry(trait_predicate.skip_binder().self_ty()).or_default();
2161 let def_id = trait_predicate.skip_binder().def_id();
2162 if Some(def_id) != tcx.lang_items().sized_trait() {
2163 // Type params are `Sized` by default, do not add that restriction to the list
2164 // if it is a positive requirement.
2165 entry.push(trait_predicate.skip_binder().def_id());
2168 ty::Predicate::Projection(projection_pred) => {
2169 projections.push(projection_pred);
2174 let generics = if types.is_empty() {
2181 .filter_map(|t| match t.kind {
2182 ty::Param(_) => Some(t.to_string()),
2183 // Avoid suggesting the following:
2184 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
2187 .collect::<Vec<_>>()
2191 let mut where_clauses = vec![];
2192 for (ty, bounds) in types {
2193 for bound in &bounds {
2194 where_clauses.push(format!("{}: {}", ty, tcx.def_path_str(*bound)));
2197 for projection in &projections {
2198 let p = projection.skip_binder();
2199 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
2200 // insert the associated types where they correspond, but for now let's be "lazy" and
2201 // propose this instead of the following valid resugaring:
2202 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
2203 where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.item_def_id), p.ty));
2205 let where_clauses = if where_clauses.is_empty() {
2208 format!(" where {}", where_clauses.join(", "))
2210 (generics, where_clauses)
2213 /// Return placeholder code for the given function.
2214 fn fn_sig_suggestion(
2216 sig: &ty::FnSig<'_>,
2218 predicates: ty::GenericPredicates<'_>,
2224 Some(match ty.kind {
2225 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2226 ty::Ref(reg, ref_ty, mutability) => {
2227 let reg = match &format!("{}", reg)[..] {
2228 "'_" | "" => String::new(),
2229 reg => format!("{} ", reg),
2232 ty::Param(param) if param.name == kw::SelfUpper => {
2233 format!("&{}{}self", reg, mutability.prefix_str())
2235 _ => format!("_: {:?}", ty),
2238 _ => format!("_: {:?}", ty),
2241 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2242 .filter_map(|arg| arg)
2243 .collect::<Vec<String>>()
2245 let output = sig.output();
2246 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2248 let unsafety = sig.unsafety.prefix_str();
2249 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
2251 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2252 // not be present in the `fn` definition, not will we account for renamed
2253 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2254 // fill in a significant portion of the missing code, and other subsequent
2255 // suggestions can help the user fix the code.
2257 "{}fn {}{}({}){}{} {{ todo!() }}",
2258 unsafety, ident, generics, args, output, where_clauses
2262 /// Return placeholder code for the given associated item.
2263 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2264 /// structured suggestion.
2265 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2267 ty::AssocKind::Method => {
2268 // We skip the binder here because the binder would deanonymize all
2269 // late-bound regions, and we don't want method signatures to show up
2270 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2271 // regions just fine, showing `fn(&MyType)`.
2274 tcx.fn_sig(assoc.def_id).skip_binder(),
2276 tcx.predicates_of(assoc.def_id),
2279 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2280 // FIXME(type_alias_impl_trait): we should print bounds here too.
2281 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2282 ty::AssocKind::Const => {
2283 let ty = tcx.type_of(assoc.def_id);
2284 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2285 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2290 /// Checks whether a type can be represented in memory. In particular, it
2291 /// identifies types that contain themselves without indirection through a
2292 /// pointer, which would mean their size is unbounded.
2293 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2294 let rty = tcx.type_of(item_def_id);
2296 // Check that it is possible to represent this type. This call identifies
2297 // (1) types that contain themselves and (2) types that contain a different
2298 // recursive type. It is only necessary to throw an error on those that
2299 // contain themselves. For case 2, there must be an inner type that will be
2300 // caught by case 1.
2301 match rty.is_representable(tcx, sp) {
2302 Representability::SelfRecursive(spans) => {
2303 let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id);
2305 err.span_label(span, "recursive without indirection");
2310 Representability::Representable | Representability::ContainsRecursive => (),
2315 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2316 let t = tcx.type_of(def_id);
2317 if let ty::Adt(def, substs) = t.kind {
2318 if def.is_struct() {
2319 let fields = &def.non_enum_variant().fields;
2320 if fields.is_empty() {
2321 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2324 let e = fields[0].ty(tcx, substs);
2325 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2326 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2327 .span_label(sp, "SIMD elements must have the same type")
2332 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2333 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2339 "SIMD vector element type should be machine type"
2349 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2350 let repr = tcx.adt_def(def_id).repr;
2352 for attr in tcx.get_attrs(def_id).iter() {
2353 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2354 if let attr::ReprPacked(pack) = r {
2355 if let Some(repr_pack) = repr.pack {
2356 if pack as u64 != repr_pack.bytes() {
2361 "type has conflicting packed representation hints"
2369 if repr.align.is_some() {
2374 "type has conflicting packed and align representation hints"
2378 if let Some(def_spans) = check_packed_inner(tcx, def_id, &mut vec![]) {
2379 let mut err = struct_span_err!(
2383 "packed type cannot transitively contain a `#[repr(align)]` type"
2386 let hir = tcx.hir();
2387 if let Some(hir_id) = hir.as_local_hir_id(def_spans[0].0) {
2388 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2390 tcx.def_span(def_spans[0].0),
2391 &format!("`{}` has a `#[repr(align)]` attribute", ident),
2396 if def_spans.len() > 2 {
2397 let mut first = true;
2398 for (adt_def, span) in def_spans.iter().skip(1).rev() {
2399 if let Some(hir_id) = hir.as_local_hir_id(*adt_def) {
2400 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2405 "`{}` contains a field of type `{}`",
2406 tcx.type_of(def_id),
2410 format!("...which contains a field of type `{}`", ident)
2425 fn check_packed_inner(
2428 stack: &mut Vec<DefId>,
2429 ) -> Option<Vec<(DefId, Span)>> {
2430 if let ty::Adt(def, substs) = tcx.type_of(def_id).kind {
2431 if def.is_struct() || def.is_union() {
2432 if def.repr.align.is_some() {
2433 return Some(vec![(def.did, DUMMY_SP)]);
2437 for field in &def.non_enum_variant().fields {
2438 if let ty::Adt(def, _) = field.ty(tcx, substs).kind {
2439 if !stack.contains(&def.did) {
2440 if let Some(mut defs) = check_packed_inner(tcx, def.did, stack) {
2441 defs.push((def.did, field.ident.span));
2454 /// Emit an error when encountering more or less than one variant in a transparent enum.
2455 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2456 let variant_spans: Vec<_> = adt
2459 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2461 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2462 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2463 err.span_label(sp, &msg);
2464 if let [start @ .., end] = &*variant_spans {
2465 for variant_span in start {
2466 err.span_label(*variant_span, "");
2468 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2473 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2475 fn bad_non_zero_sized_fields<'tcx>(
2477 adt: &'tcx ty::AdtDef,
2479 field_spans: impl Iterator<Item = Span>,
2482 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2483 let mut err = struct_span_err!(
2487 "{}transparent {} {}",
2488 if adt.is_enum() { "the variant of a " } else { "" },
2492 err.span_label(sp, &msg);
2493 for sp in field_spans {
2494 err.span_label(sp, "this field is non-zero-sized");
2499 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2500 let adt = tcx.adt_def(def_id);
2501 if !adt.repr.transparent() {
2504 let sp = tcx.sess.source_map().def_span(sp);
2506 if adt.is_union() && !tcx.features().transparent_unions {
2508 &tcx.sess.parse_sess,
2509 sym::transparent_unions,
2511 "transparent unions are unstable",
2516 if adt.variants.len() != 1 {
2517 bad_variant_count(tcx, adt, sp, def_id);
2518 if adt.variants.is_empty() {
2519 // Don't bother checking the fields. No variants (and thus no fields) exist.
2524 // For each field, figure out if it's known to be a ZST and align(1)
2525 let field_infos = adt.all_fields().map(|field| {
2526 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2527 let param_env = tcx.param_env(field.did);
2528 let layout = tcx.layout_of(param_env.and(ty));
2529 // We are currently checking the type this field came from, so it must be local
2530 let span = tcx.hir().span_if_local(field.did).unwrap();
2531 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2532 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2536 let non_zst_fields =
2537 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2538 let non_zst_count = non_zst_fields.clone().count();
2539 if non_zst_count != 1 {
2540 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2542 for (span, zst, align1) in field_infos {
2548 "zero-sized field in transparent {} has alignment larger than 1",
2551 .span_label(span, "has alignment larger than 1")
2557 #[allow(trivial_numeric_casts)]
2558 pub fn check_enum<'tcx>(
2561 vs: &'tcx [hir::Variant<'tcx>],
2564 let def_id = tcx.hir().local_def_id(id);
2565 let def = tcx.adt_def(def_id);
2566 def.destructor(tcx); // force the destructor to be evaluated
2569 let attributes = tcx.get_attrs(def_id);
2570 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2575 "unsupported representation for zero-variant enum"
2577 .span_label(sp, "zero-variant enum")
2582 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2583 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2584 if !tcx.features().repr128 {
2586 &tcx.sess.parse_sess,
2589 "repr with 128-bit type is unstable",
2596 if let Some(ref e) = v.disr_expr {
2597 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2601 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2602 let is_unit = |var: &hir::Variant<'_>| match var.data {
2603 hir::VariantData::Unit(..) => true,
2607 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2608 let has_non_units = vs.iter().any(|var| !is_unit(var));
2609 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2610 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2612 if disr_non_unit || (disr_units && has_non_units) {
2614 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2619 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2620 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2621 // Check for duplicate discriminant values
2622 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2623 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2624 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2625 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2626 let i_span = match variant_i.disr_expr {
2627 Some(ref expr) => tcx.hir().span(expr.hir_id),
2628 None => tcx.hir().span(variant_i_hir_id),
2630 let span = match v.disr_expr {
2631 Some(ref expr) => tcx.hir().span(expr.hir_id),
2638 "discriminant value `{}` already exists",
2641 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2642 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2645 disr_vals.push(discr);
2648 check_representable(tcx, sp, def_id);
2649 check_transparent(tcx, sp, def_id);
2652 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath<'_>) {
2657 "expected unit struct, unit variant or constant, found {} `{}`",
2659 hir::print::to_string(&tcx.hir(), |s| s.print_qpath(qpath, false))
2664 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2665 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2669 fn item_def_id(&self) -> Option<DefId> {
2673 fn default_constness_for_trait_bounds(&self) -> hir::Constness {
2674 // FIXME: refactor this into a method
2675 let node = self.tcx.hir().get(self.body_id);
2676 if let Some(fn_like) = FnLikeNode::from_node(node) {
2679 hir::Constness::NotConst
2683 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2685 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2686 let item_id = tcx.hir().ty_param_owner(hir_id);
2687 let item_def_id = tcx.hir().local_def_id(item_id);
2688 let generics = tcx.generics_of(item_def_id);
2689 let index = generics.param_def_id_to_index[&def_id];
2690 ty::GenericPredicates {
2692 predicates: tcx.arena.alloc_from_iter(self.param_env.caller_bounds.iter().filter_map(
2693 |&predicate| match predicate {
2694 ty::Predicate::Trait(ref data, _)
2695 if data.skip_binder().self_ty().is_param(index) =>
2697 // HACK(eddyb) should get the original `Span`.
2698 let span = tcx.def_span(def_id);
2699 Some((predicate, span))
2707 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2709 Some(def) => infer::EarlyBoundRegion(span, def.name),
2710 None => infer::MiscVariable(span),
2712 Some(self.next_region_var(v))
2715 fn allow_ty_infer(&self) -> bool {
2719 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2720 if let Some(param) = param {
2721 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2726 self.next_ty_var(TypeVariableOrigin {
2727 kind: TypeVariableOriginKind::TypeInference,
2736 param: Option<&ty::GenericParamDef>,
2738 ) -> &'tcx Const<'tcx> {
2739 if let Some(param) = param {
2740 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2745 self.next_const_var(
2747 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2752 fn projected_ty_from_poly_trait_ref(
2756 item_segment: &hir::PathSegment<'_>,
2757 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2759 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2761 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2765 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
2774 self.tcx().mk_projection(item_def_id, item_substs)
2777 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2778 if ty.has_escaping_bound_vars() {
2779 ty // FIXME: normalization and escaping regions
2781 self.normalize_associated_types_in(span, &ty)
2785 fn set_tainted_by_errors(&self) {
2786 self.infcx.set_tainted_by_errors()
2789 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2790 self.write_ty(hir_id, ty)
2794 /// Controls whether the arguments are tupled. This is used for the call
2797 /// Tupling means that all call-side arguments are packed into a tuple and
2798 /// passed as a single parameter. For example, if tupling is enabled, this
2801 /// fn f(x: (isize, isize))
2803 /// Can be called as:
2810 #[derive(Clone, Eq, PartialEq)]
2811 enum TupleArgumentsFlag {
2816 /// Controls how we perform fallback for unconstrained
2819 /// Do not fallback type variables to opaque types.
2821 /// Perform all possible kinds of fallback, including
2822 /// turning type variables to opaque types.
2826 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2828 inh: &'a Inherited<'a, 'tcx>,
2829 param_env: ty::ParamEnv<'tcx>,
2830 body_id: hir::HirId,
2831 ) -> FnCtxt<'a, 'tcx> {
2835 err_count_on_creation: inh.tcx.sess.err_count(),
2837 ret_coercion_span: RefCell::new(None),
2838 resume_yield_tys: None,
2839 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
2840 diverges: Cell::new(Diverges::Maybe),
2841 has_errors: Cell::new(false),
2842 enclosing_breakables: RefCell::new(EnclosingBreakables {
2844 by_id: Default::default(),
2850 pub fn sess(&self) -> &Session {
2854 pub fn errors_reported_since_creation(&self) -> bool {
2855 self.tcx.sess.err_count() > self.err_count_on_creation
2858 /// Produces warning on the given node, if the current point in the
2859 /// function is unreachable, and there hasn't been another warning.
2860 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2861 // FIXME: Combine these two 'if' expressions into one once
2862 // let chains are implemented
2863 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2864 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2865 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2866 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2867 if !span.is_desugaring(DesugaringKind::CondTemporary)
2868 && !span.is_desugaring(DesugaringKind::Async)
2869 && !orig_span.is_desugaring(DesugaringKind::Await)
2871 self.diverges.set(Diverges::WarnedAlways);
2873 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2875 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, |lint| {
2876 let msg = format!("unreachable {}", kind);
2878 .span_label(span, &msg)
2882 .unwrap_or("any code following this expression is unreachable"),
2890 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
2891 ObligationCause::new(span, self.body_id, code)
2894 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2895 self.cause(span, ObligationCauseCode::MiscObligation)
2898 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2899 /// version (resolve_vars_if_possible), this version will
2900 /// also select obligations if it seems useful, in an effort
2901 /// to get more type information.
2902 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2903 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2905 // No Infer()? Nothing needs doing.
2906 if !ty.has_infer_types_or_consts() {
2907 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2911 // If `ty` is a type variable, see whether we already know what it is.
2912 ty = self.resolve_vars_if_possible(&ty);
2913 if !ty.has_infer_types_or_consts() {
2914 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2918 // If not, try resolving pending obligations as much as
2919 // possible. This can help substantially when there are
2920 // indirect dependencies that don't seem worth tracking
2922 self.select_obligations_where_possible(false, |_| {});
2923 ty = self.resolve_vars_if_possible(&ty);
2925 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2929 fn record_deferred_call_resolution(
2931 closure_def_id: DefId,
2932 r: DeferredCallResolution<'tcx>,
2934 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2935 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2938 fn remove_deferred_call_resolutions(
2940 closure_def_id: DefId,
2941 ) -> Vec<DeferredCallResolution<'tcx>> {
2942 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2943 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2946 pub fn tag(&self) -> String {
2947 format!("{:p}", self)
2950 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2951 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
2952 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
2957 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2959 "write_ty({:?}, {:?}) in fcx {}",
2961 self.resolve_vars_if_possible(&ty),
2964 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2966 if ty.references_error() {
2967 self.has_errors.set(true);
2968 self.set_tainted_by_errors();
2972 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2973 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2976 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2977 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2980 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
2981 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2982 self.write_resolution(hir_id, Ok((DefKind::AssocFn, method.def_id)));
2983 self.write_substs(hir_id, method.substs);
2985 // When the method is confirmed, the `method.substs` includes
2986 // parameters from not just the method, but also the impl of
2987 // the method -- in particular, the `Self` type will be fully
2988 // resolved. However, those are not something that the "user
2989 // specified" -- i.e., those types come from the inferred type
2990 // of the receiver, not something the user wrote. So when we
2991 // create the user-substs, we want to replace those earlier
2992 // types with just the types that the user actually wrote --
2993 // that is, those that appear on the *method itself*.
2995 // As an example, if the user wrote something like
2996 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2997 // type of `foo` (possibly adjusted), but we don't want to
2998 // include that. We want just the `[_, u32]` part.
2999 if !method.substs.is_noop() {
3000 let method_generics = self.tcx.generics_of(method.def_id);
3001 if !method_generics.params.is_empty() {
3002 let user_type_annotation = self.infcx.probe(|_| {
3003 let user_substs = UserSubsts {
3004 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
3005 let i = param.index as usize;
3006 if i < method_generics.parent_count {
3007 self.infcx.var_for_def(DUMMY_SP, param)
3012 user_self_ty: None, // not relevant here
3015 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3021 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
3022 self.write_user_type_annotation(hir_id, user_type_annotation);
3027 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
3028 if !substs.is_noop() {
3029 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
3031 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
3035 /// Given the substs that we just converted from the HIR, try to
3036 /// canonicalize them and store them as user-given substitutions
3037 /// (i.e., substitutions that must be respected by the NLL check).
3039 /// This should be invoked **before any unifications have
3040 /// occurred**, so that annotations like `Vec<_>` are preserved
3042 pub fn write_user_type_annotation_from_substs(
3046 substs: SubstsRef<'tcx>,
3047 user_self_ty: Option<UserSelfTy<'tcx>>,
3050 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
3051 user_self_ty={:?} in fcx {}",
3059 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
3060 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3062 UserSubsts { substs, user_self_ty },
3064 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
3065 self.write_user_type_annotation(hir_id, canonicalized);
3069 pub fn write_user_type_annotation(
3072 canonical_user_type_annotation: CanonicalUserType<'tcx>,
3075 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
3077 canonical_user_type_annotation,
3081 if !canonical_user_type_annotation.is_identity() {
3084 .user_provided_types_mut()
3085 .insert(hir_id, canonical_user_type_annotation);
3087 debug!("write_user_type_annotation: skipping identity substs");
3091 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
3092 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
3098 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
3099 Entry::Vacant(entry) => {
3102 Entry::Occupied(mut entry) => {
3103 debug!(" - composing on top of {:?}", entry.get());
3104 match (&entry.get()[..], &adj[..]) {
3105 // Applying any adjustment on top of a NeverToAny
3106 // is a valid NeverToAny adjustment, because it can't
3108 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3110 Adjustment { kind: Adjust::Deref(_), .. },
3111 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3113 Adjustment { kind: Adjust::Deref(_), .. },
3114 .. // Any following adjustments are allowed.
3116 // A reborrow has no effect before a dereference.
3118 // FIXME: currently we never try to compose autoderefs
3119 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3121 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3122 expr, entry.get(), adj)
3124 *entry.get_mut() = adj;
3129 /// Basically whenever we are converting from a type scheme into
3130 /// the fn body space, we always want to normalize associated
3131 /// types as well. This function combines the two.
3132 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3134 T: TypeFoldable<'tcx>,
3136 let value = value.subst(self.tcx, substs);
3137 let result = self.normalize_associated_types_in(span, &value);
3138 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3142 /// As `instantiate_type_scheme`, but for the bounds found in a
3143 /// generic type scheme.
3144 fn instantiate_bounds(
3148 substs: SubstsRef<'tcx>,
3149 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3150 let bounds = self.tcx.predicates_of(def_id);
3151 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3152 let result = bounds.instantiate(self.tcx, substs);
3153 let result = self.normalize_associated_types_in(span, &result);
3155 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3156 bounds, substs, result, spans,
3161 /// Replaces the opaque types from the given value with type variables,
3162 /// and records the `OpaqueTypeMap` for later use during writeback. See
3163 /// `InferCtxt::instantiate_opaque_types` for more details.
3164 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3166 parent_id: hir::HirId,
3170 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3172 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3173 parent_def_id, value
3176 let (value, opaque_type_map) =
3177 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3185 let mut opaque_types = self.opaque_types.borrow_mut();
3186 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3187 for (ty, decl) in opaque_type_map {
3188 let _ = opaque_types.insert(ty, decl);
3189 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3195 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3197 T: TypeFoldable<'tcx>,
3199 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3202 fn normalize_associated_types_in_as_infer_ok<T>(
3206 ) -> InferOk<'tcx, T>
3208 T: TypeFoldable<'tcx>,
3210 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3213 pub fn require_type_meets(
3217 code: traits::ObligationCauseCode<'tcx>,
3220 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3223 pub fn require_type_is_sized(
3227 code: traits::ObligationCauseCode<'tcx>,
3229 if !ty.references_error() {
3230 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3231 self.require_type_meets(ty, span, code, lang_item);
3235 pub fn require_type_is_sized_deferred(
3239 code: traits::ObligationCauseCode<'tcx>,
3241 if !ty.references_error() {
3242 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3246 pub fn register_bound(
3250 cause: traits::ObligationCause<'tcx>,
3252 if !ty.references_error() {
3253 self.fulfillment_cx.borrow_mut().register_bound(
3263 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3264 let t = AstConv::ast_ty_to_ty(self, ast_t);
3265 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3269 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3270 let ty = self.to_ty(ast_ty);
3271 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3273 if Self::can_contain_user_lifetime_bounds(ty) {
3274 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3275 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3276 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3282 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3283 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3284 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3287 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3288 AstConv::ast_const_to_const(self, ast_c, ty)
3291 // If the type given by the user has free regions, save it for later, since
3292 // NLL would like to enforce those. Also pass in types that involve
3293 // projections, since those can resolve to `'static` bounds (modulo #54940,
3294 // which hopefully will be fixed by the time you see this comment, dear
3295 // reader, although I have my doubts). Also pass in types with inference
3296 // types, because they may be repeated. Other sorts of things are already
3297 // sufficiently enforced with erased regions. =)
3298 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3300 T: TypeFoldable<'tcx>,
3302 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3305 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3306 match self.tables.borrow().node_types().get(id) {
3308 None if self.is_tainted_by_errors() => self.tcx.types.err,
3311 "no type for node {}: {} in fcx {}",
3313 self.tcx.hir().node_to_string(id),
3320 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3321 /// outlive the region `r`.
3322 pub fn register_wf_obligation(
3326 code: traits::ObligationCauseCode<'tcx>,
3328 // WF obligations never themselves fail, so no real need to give a detailed cause:
3329 let cause = traits::ObligationCause::new(span, self.body_id, code);
3330 self.register_predicate(traits::Obligation::new(
3333 ty::Predicate::WellFormed(ty),
3337 /// Registers obligations that all types appearing in `substs` are well-formed.
3338 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3339 for ty in substs.types() {
3340 if !ty.references_error() {
3341 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3346 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3347 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3348 /// trait/region obligations.
3350 /// For example, if there is a function:
3353 /// fn foo<'a,T:'a>(...)
3356 /// and a reference:
3362 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3363 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3364 pub fn add_obligations_for_parameters(
3366 cause: traits::ObligationCause<'tcx>,
3367 predicates: &ty::InstantiatedPredicates<'tcx>,
3369 assert!(!predicates.has_escaping_bound_vars());
3371 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3373 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3374 self.register_predicate(obligation);
3378 // FIXME(arielb1): use this instead of field.ty everywhere
3379 // Only for fields! Returns <none> for methods>
3380 // Indifferent to privacy flags
3384 field: &'tcx ty::FieldDef,
3385 substs: SubstsRef<'tcx>,
3387 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3390 fn check_casts(&self) {
3391 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3392 for cast in deferred_cast_checks.drain(..) {
3397 fn resolve_generator_interiors(&self, def_id: DefId) {
3398 let mut generators = self.deferred_generator_interiors.borrow_mut();
3399 for (body_id, interior, kind) in generators.drain(..) {
3400 self.select_obligations_where_possible(false, |_| {});
3401 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3405 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3407 // - Unconstrained ints are replaced with `i32`.
3409 // - Unconstrained floats are replaced with with `f64`.
3411 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3412 // is enabled. Otherwise, they are replaced with `()`.
3414 // Fallback becomes very dubious if we have encountered type-checking errors.
3415 // In that case, fallback to Error.
3416 // The return value indicates whether fallback has occurred.
3417 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3418 use rustc::ty::error::UnconstrainedNumeric::Neither;
3419 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3421 assert!(ty.is_ty_infer());
3422 let fallback = match self.type_is_unconstrained_numeric(ty) {
3423 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3424 UnconstrainedInt => self.tcx.types.i32,
3425 UnconstrainedFloat => self.tcx.types.f64,
3426 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3428 // This type variable was created from the instantiation of an opaque
3429 // type. The fact that we're attempting to perform fallback for it
3430 // means that the function neither constrained it to a concrete
3431 // type, nor to the opaque type itself.
3433 // For example, in this code:
3436 // type MyType = impl Copy;
3437 // fn defining_use() -> MyType { true }
3438 // fn other_use() -> MyType { defining_use() }
3441 // `defining_use` will constrain the instantiated inference
3442 // variable to `bool`, while `other_use` will constrain
3443 // the instantiated inference variable to `MyType`.
3445 // When we process opaque types during writeback, we
3446 // will handle cases like `other_use`, and not count
3447 // them as defining usages
3449 // However, we also need to handle cases like this:
3452 // pub type Foo = impl Copy;
3453 // fn produce() -> Option<Foo> {
3458 // In the above snippet, the inference variable created by
3459 // instantiating `Option<Foo>` will be completely unconstrained.
3460 // We treat this as a non-defining use by making the inference
3461 // variable fall back to the opaque type itself.
3462 if let FallbackMode::All = mode {
3463 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3465 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3477 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3478 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3482 fn select_all_obligations_or_error(&self) {
3483 debug!("select_all_obligations_or_error");
3484 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3485 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3489 /// Select as many obligations as we can at present.
3490 fn select_obligations_where_possible(
3492 fallback_has_occurred: bool,
3493 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3495 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3496 if let Err(mut errors) = result {
3497 mutate_fullfillment_errors(&mut errors);
3498 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3502 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3503 /// returns a type of `&T`, but the actual type we assign to the
3504 /// *expression* is `T`. So this function just peels off the return
3505 /// type by one layer to yield `T`.
3506 fn make_overloaded_place_return_type(
3508 method: MethodCallee<'tcx>,
3509 ) -> ty::TypeAndMut<'tcx> {
3510 // extract method return type, which will be &T;
3511 let ret_ty = method.sig.output();
3513 // method returns &T, but the type as visible to user is T, so deref
3514 ret_ty.builtin_deref(true).unwrap()
3519 expr: &hir::Expr<'_>,
3520 base_expr: &'tcx hir::Expr<'tcx>,
3524 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3525 // FIXME(#18741) -- this is almost but not quite the same as the
3526 // autoderef that normal method probing does. They could likely be
3529 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3530 let mut result = None;
3531 while result.is_none() && autoderef.next().is_some() {
3532 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3534 autoderef.finalize(self);
3538 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3539 /// (and otherwise adjust) `base_expr`, looking for a type which either
3540 /// supports builtin indexing or overloaded indexing.
3541 /// This loop implements one step in that search; the autoderef loop
3542 /// is implemented by `lookup_indexing`.
3545 expr: &hir::Expr<'_>,
3546 base_expr: &hir::Expr<'_>,
3547 autoderef: &Autoderef<'a, 'tcx>,
3550 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3551 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3553 "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3555 expr, base_expr, adjusted_ty, index_ty
3558 for &unsize in &[false, true] {
3559 let mut self_ty = adjusted_ty;
3561 // We only unsize arrays here.
3562 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3563 self_ty = self.tcx.mk_slice(element_ty);
3569 // If some lookup succeeds, write callee into table and extract index/element
3570 // type from the method signature.
3571 // If some lookup succeeded, install method in table
3572 let input_ty = self.next_ty_var(TypeVariableOrigin {
3573 kind: TypeVariableOriginKind::AutoDeref,
3574 span: base_expr.span,
3576 let method = self.try_overloaded_place_op(
3584 let result = method.map(|ok| {
3585 debug!("try_index_step: success, using overloaded indexing");
3586 let method = self.register_infer_ok_obligations(ok);
3588 let mut adjustments = autoderef.adjust_steps(self, needs);
3589 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3590 let mutbl = match r_mutbl {
3591 hir::Mutability::Not => AutoBorrowMutability::Not,
3592 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3593 // Indexing can be desugared to a method call,
3594 // so maybe we could use two-phase here.
3595 // See the documentation of AllowTwoPhase for why that's
3596 // not the case today.
3597 allow_two_phase_borrow: AllowTwoPhase::No,
3600 adjustments.push(Adjustment {
3601 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3604 .mk_ref(region, ty::TypeAndMut { mutbl: r_mutbl, ty: adjusted_ty }),
3608 adjustments.push(Adjustment {
3609 kind: Adjust::Pointer(PointerCast::Unsize),
3610 target: method.sig.inputs()[0],
3613 self.apply_adjustments(base_expr, adjustments);
3615 self.write_method_call(expr.hir_id, method);
3616 (input_ty, self.make_overloaded_place_return_type(method).ty)
3618 if result.is_some() {
3626 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3627 let (tr, name) = match (op, is_mut) {
3628 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3629 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3630 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3631 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3633 (tr, ast::Ident::with_dummy_span(name))
3636 fn try_overloaded_place_op(
3640 arg_tys: &[Ty<'tcx>],
3643 ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
3644 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})", span, base_ty, needs, op);
3646 // Try Mut first, if needed.
3647 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3648 let method = match (needs, mut_tr) {
3649 (Needs::MutPlace, Some(trait_did)) => {
3650 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3655 // Otherwise, fall back to the immutable version.
3656 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3657 let method = match (method, imm_tr) {
3658 (None, Some(trait_did)) => {
3659 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3661 (method, _) => method,
3667 fn check_method_argument_types(
3670 expr: &'tcx hir::Expr<'tcx>,
3671 method: Result<MethodCallee<'tcx>, ()>,
3672 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3673 tuple_arguments: TupleArgumentsFlag,
3674 expected: Expectation<'tcx>,
3676 let has_error = match method {
3677 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3681 let err_inputs = self.err_args(args_no_rcvr.len());
3683 let err_inputs = match tuple_arguments {
3684 DontTupleArguments => err_inputs,
3685 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3688 self.check_argument_types(
3698 return self.tcx.types.err;
3701 let method = method.unwrap();
3702 // HACK(eddyb) ignore self in the definition (see above).
3703 let expected_arg_tys = self.expected_inputs_for_expected_output(
3706 method.sig.output(),
3707 &method.sig.inputs()[1..],
3709 self.check_argument_types(
3712 &method.sig.inputs()[1..],
3713 &expected_arg_tys[..],
3715 method.sig.c_variadic,
3717 self.tcx.hir().span_if_local(method.def_id),
3722 fn self_type_matches_expected_vid(
3724 trait_ref: ty::PolyTraitRef<'tcx>,
3725 expected_vid: ty::TyVid,
3727 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3729 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3730 trait_ref, self_ty, expected_vid
3732 match self_ty.kind {
3733 ty::Infer(ty::TyVar(found_vid)) => {
3734 // FIXME: consider using `sub_root_var` here so we
3735 // can see through subtyping.
3736 let found_vid = self.root_var(found_vid);
3737 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3738 expected_vid == found_vid
3744 fn obligations_for_self_ty<'b>(
3747 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3750 // FIXME: consider using `sub_root_var` here so we
3751 // can see through subtyping.
3752 let ty_var_root = self.root_var(self_ty);
3754 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3757 self.fulfillment_cx.borrow().pending_obligations()
3762 .pending_obligations()
3764 .filter_map(move |obligation| match obligation.predicate {
3765 ty::Predicate::Projection(ref data) => {
3766 Some((data.to_poly_trait_ref(self.tcx), obligation))
3768 ty::Predicate::Trait(ref data, _) => Some((data.to_poly_trait_ref(), obligation)),
3769 ty::Predicate::Subtype(..) => None,
3770 ty::Predicate::RegionOutlives(..) => None,
3771 ty::Predicate::TypeOutlives(..) => None,
3772 ty::Predicate::WellFormed(..) => None,
3773 ty::Predicate::ObjectSafe(..) => None,
3774 ty::Predicate::ConstEvaluatable(..) => None,
3775 // N.B., this predicate is created by breaking down a
3776 // `ClosureType: FnFoo()` predicate, where
3777 // `ClosureType` represents some `Closure`. It can't
3778 // possibly be referring to the current closure,
3779 // because we haven't produced the `Closure` for
3780 // this closure yet; this is exactly why the other
3781 // code is looking for a self type of a unresolved
3782 // inference variable.
3783 ty::Predicate::ClosureKind(..) => None,
3785 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3788 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3789 self.obligations_for_self_ty(self_ty)
3790 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3793 /// Generic function that factors out common logic from function calls,
3794 /// method calls and overloaded operators.
3795 fn check_argument_types(
3798 expr: &'tcx hir::Expr<'tcx>,
3799 fn_inputs: &[Ty<'tcx>],
3800 expected_arg_tys: &[Ty<'tcx>],
3801 args: &'tcx [hir::Expr<'tcx>],
3803 tuple_arguments: TupleArgumentsFlag,
3804 def_span: Option<Span>,
3807 // Grab the argument types, supplying fresh type variables
3808 // if the wrong number of arguments were supplied
3809 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3811 // All the input types from the fn signature must outlive the call
3812 // so as to validate implied bounds.
3813 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3814 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3817 let expected_arg_count = fn_inputs.len();
3819 let param_count_error = |expected_count: usize,
3824 let (span, start_span, args) = match &expr.kind {
3825 hir::ExprKind::Call(hir::Expr { span, .. }, args) => (*span, *span, &args[..]),
3826 hir::ExprKind::MethodCall(path_segment, span, args) => (
3828 // `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
3831 .and_then(|args| args.args.iter().last())
3832 // Account for `foo.bar::<T>()`.
3834 // Skip the closing `>`.
3837 .next_point(tcx.sess.source_map().next_point(arg.span()))
3840 &args[1..], // Skip the receiver.
3842 k => span_bug!(sp, "checking argument types on a non-call: `{:?}`", k),
3844 let arg_spans = if args.is_empty() {
3846 // ^^^-- supplied 0 arguments
3848 // expected 2 arguments
3849 vec![tcx.sess.source_map().next_point(start_span).with_hi(sp.hi())]
3852 // ^^^ - - - supplied 3 arguments
3854 // expected 2 arguments
3855 args.iter().map(|arg| arg.span).collect::<Vec<Span>>()
3858 let mut err = tcx.sess.struct_span_err_with_code(
3861 "this function takes {}{} but {} {} supplied",
3862 if c_variadic { "at least " } else { "" },
3863 potentially_plural_count(expected_count, "argument"),
3864 potentially_plural_count(arg_count, "argument"),
3865 if arg_count == 1 { "was" } else { "were" }
3867 DiagnosticId::Error(error_code.to_owned()),
3869 let label = format!("supplied {}", potentially_plural_count(arg_count, "argument"));
3870 for (i, span) in arg_spans.into_iter().enumerate() {
3873 if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
3877 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3878 err.span_label(def_s, "defined here");
3881 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3882 // remove closing `)` from the span
3883 let sugg_span = sugg_span.shrink_to_lo();
3884 err.span_suggestion(
3886 "expected the unit value `()`; create it with empty parentheses",
3888 Applicability::MachineApplicable,
3895 if c_variadic { "at least " } else { "" },
3896 potentially_plural_count(expected_count, "argument")
3903 let mut expected_arg_tys = expected_arg_tys.to_vec();
3905 let formal_tys = if tuple_arguments == TupleArguments {
3906 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3907 match tuple_type.kind {
3908 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3909 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3910 expected_arg_tys = vec![];
3911 self.err_args(args.len())
3913 ty::Tuple(arg_types) => {
3914 expected_arg_tys = match expected_arg_tys.get(0) {
3915 Some(&ty) => match ty.kind {
3916 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3921 arg_types.iter().map(|k| k.expect_ty()).collect()
3928 "cannot use call notation; the first type parameter \
3929 for the function trait is neither a tuple nor unit"
3932 expected_arg_tys = vec![];
3933 self.err_args(args.len())
3936 } else if expected_arg_count == supplied_arg_count {
3938 } else if c_variadic {
3939 if supplied_arg_count >= expected_arg_count {
3942 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3943 expected_arg_tys = vec![];
3944 self.err_args(supplied_arg_count)
3947 // is the missing argument of type `()`?
3948 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3949 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3950 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3951 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3955 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3957 expected_arg_tys = vec![];
3958 self.err_args(supplied_arg_count)
3962 "check_argument_types: formal_tys={:?}",
3963 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
3966 // If there is no expectation, expect formal_tys.
3967 let expected_arg_tys =
3968 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
3970 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3972 // Check the arguments.
3973 // We do this in a pretty awful way: first we type-check any arguments
3974 // that are not closures, then we type-check the closures. This is so
3975 // that we have more information about the types of arguments when we
3976 // type-check the functions. This isn't really the right way to do this.
3977 for &check_closures in &[false, true] {
3978 debug!("check_closures={}", check_closures);
3980 // More awful hacks: before we check argument types, try to do
3981 // an "opportunistic" vtable resolution of any trait bounds on
3982 // the call. This helps coercions.
3984 self.select_obligations_where_possible(false, |errors| {
3985 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3986 self.point_at_arg_instead_of_call_if_possible(
3988 &final_arg_types[..],
3995 // For C-variadic functions, we don't have a declared type for all of
3996 // the arguments hence we only do our usual type checking with
3997 // the arguments who's types we do know.
3998 let t = if c_variadic {
4000 } else if tuple_arguments == TupleArguments {
4005 for (i, arg) in args.iter().take(t).enumerate() {
4006 // Warn only for the first loop (the "no closures" one).
4007 // Closure arguments themselves can't be diverging, but
4008 // a previous argument can, e.g., `foo(panic!(), || {})`.
4009 if !check_closures {
4010 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
4013 let is_closure = match arg.kind {
4014 ExprKind::Closure(..) => true,
4018 if is_closure != check_closures {
4022 debug!("checking the argument");
4023 let formal_ty = formal_tys[i];
4025 // The special-cased logic below has three functions:
4026 // 1. Provide as good of an expected type as possible.
4027 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
4029 let checked_ty = self.check_expr_with_expectation(&arg, expected);
4031 // 2. Coerce to the most detailed type that could be coerced
4032 // to, which is `expected_ty` if `rvalue_hint` returns an
4033 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
4034 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
4035 // We're processing function arguments so we definitely want to use
4036 // two-phase borrows.
4037 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
4038 final_arg_types.push((i, checked_ty, coerce_ty));
4040 // 3. Relate the expected type and the formal one,
4041 // if the expected type was used for the coercion.
4042 self.demand_suptype(arg.span, formal_ty, coerce_ty);
4046 // We also need to make sure we at least write the ty of the other
4047 // arguments which we skipped above.
4049 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
4050 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
4051 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
4054 for arg in args.iter().skip(expected_arg_count) {
4055 let arg_ty = self.check_expr(&arg);
4057 // There are a few types which get autopromoted when passed via varargs
4058 // in C but we just error out instead and require explicit casts.
4059 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
4061 ty::Float(ast::FloatTy::F32) => {
4062 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
4064 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
4065 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
4067 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
4068 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
4071 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
4072 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
4073 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
4081 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
4082 vec![self.tcx.types.err; len]
4085 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
4086 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
4087 /// reference a type argument. The reason to walk also the checked type is that the coerced type
4088 /// can be not easily comparable with predicate type (because of coercion). If the types match
4089 /// for either checked or coerced type, and there's only *one* argument that does, we point at
4090 /// the corresponding argument's expression span instead of the `fn` call path span.
4091 fn point_at_arg_instead_of_call_if_possible(
4093 errors: &mut Vec<traits::FulfillmentError<'_>>,
4094 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
4096 args: &'tcx [hir::Expr<'tcx>],
4098 // We *do not* do this for desugared call spans to keep good diagnostics when involving
4099 // the `?` operator.
4100 if call_sp.desugaring_kind().is_some() {
4104 for error in errors {
4105 // Only if the cause is somewhere inside the expression we want try to point at arg.
4106 // Otherwise, it means that the cause is somewhere else and we should not change
4107 // anything because we can break the correct span.
4108 if !call_sp.contains(error.obligation.cause.span) {
4112 if let ty::Predicate::Trait(predicate, _) = error.obligation.predicate {
4113 // Collect the argument position for all arguments that could have caused this
4114 // `FulfillmentError`.
4115 let mut referenced_in = final_arg_types
4117 .map(|(i, checked_ty, _)| (i, checked_ty))
4118 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
4119 .flat_map(|(i, ty)| {
4120 let ty = self.resolve_vars_if_possible(ty);
4121 // We walk the argument type because the argument's type could have
4122 // been `Option<T>`, but the `FulfillmentError` references `T`.
4124 .filter(|&ty| ty == predicate.skip_binder().self_ty())
4127 .collect::<Vec<_>>();
4129 // Both checked and coerced types could have matched, thus we need to remove
4131 referenced_in.dedup();
4133 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
4134 // We make sure that only *one* argument matches the obligation failure
4135 // and we assign the obligation's span to its expression's.
4136 error.obligation.cause.span = args[ref_in].span;
4137 error.points_at_arg_span = true;
4143 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4144 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4145 /// were caused by them. If they were, we point at the corresponding type argument's span
4146 /// instead of the `fn` call path span.
4147 fn point_at_type_arg_instead_of_call_if_possible(
4149 errors: &mut Vec<traits::FulfillmentError<'_>>,
4150 call_expr: &'tcx hir::Expr<'tcx>,
4152 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4153 if let hir::ExprKind::Path(qpath) = &path.kind {
4154 if let hir::QPath::Resolved(_, path) = &qpath {
4155 for error in errors {
4156 if let ty::Predicate::Trait(predicate, _) = error.obligation.predicate {
4157 // If any of the type arguments in this path segment caused the
4158 // `FullfillmentError`, point at its span (#61860).
4162 .filter_map(|seg| seg.args.as_ref())
4163 .flat_map(|a| a.args.iter())
4165 if let hir::GenericArg::Type(hir_ty) = &arg {
4166 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4169 // Avoid ICE with associated types. As this is best
4170 // effort only, it's ok to ignore the case. It
4171 // would trigger in `is_send::<T::AssocType>();`
4172 // from `typeck-default-trait-impl-assoc-type.rs`.
4174 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4175 let ty = self.resolve_vars_if_possible(&ty);
4176 if ty == predicate.skip_binder().self_ty() {
4177 error.obligation.cause.span = hir_ty.span;
4189 // AST fragment checking
4190 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4194 ast::LitKind::Str(..) => tcx.mk_static_str(),
4195 ast::LitKind::ByteStr(ref v) => {
4196 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4198 ast::LitKind::Byte(_) => tcx.types.u8,
4199 ast::LitKind::Char(_) => tcx.types.char,
4200 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4201 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4202 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4203 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4204 ty::Int(_) | ty::Uint(_) => Some(ty),
4205 ty::Char => Some(tcx.types.u8),
4206 ty::RawPtr(..) => Some(tcx.types.usize),
4207 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4210 opt_ty.unwrap_or_else(|| self.next_int_var())
4212 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4213 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4214 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4215 ty::Float(_) => Some(ty),
4218 opt_ty.unwrap_or_else(|| self.next_float_var())
4220 ast::LitKind::Bool(_) => tcx.types.bool,
4221 ast::LitKind::Err(_) => tcx.types.err,
4225 // Determine the `Self` type, using fresh variables for all variables
4226 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4227 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4229 pub fn impl_self_ty(
4231 span: Span, // (potential) receiver for this impl
4233 ) -> TypeAndSubsts<'tcx> {
4234 let ity = self.tcx.type_of(did);
4235 debug!("impl_self_ty: ity={:?}", ity);
4237 let substs = self.fresh_substs_for_item(span, did);
4238 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4240 TypeAndSubsts { substs, ty: substd_ty }
4243 /// Unifies the output type with the expected type early, for more coercions
4244 /// and forward type information on the input expressions.
4245 fn expected_inputs_for_expected_output(
4248 expected_ret: Expectation<'tcx>,
4249 formal_ret: Ty<'tcx>,
4250 formal_args: &[Ty<'tcx>],
4251 ) -> Vec<Ty<'tcx>> {
4252 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4253 let ret_ty = match expected_ret.only_has_type(self) {
4255 None => return Vec::new(),
4257 let expect_args = self
4258 .fudge_inference_if_ok(|| {
4259 // Attempt to apply a subtyping relationship between the formal
4260 // return type (likely containing type variables if the function
4261 // is polymorphic) and the expected return type.
4262 // No argument expectations are produced if unification fails.
4263 let origin = self.misc(call_span);
4264 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4266 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4267 // to identity so the resulting type is not constrained.
4270 // Process any obligations locally as much as
4271 // we can. We don't care if some things turn
4272 // out unconstrained or ambiguous, as we're
4273 // just trying to get hints here.
4274 self.save_and_restore_in_snapshot_flag(|_| {
4275 let mut fulfill = TraitEngine::new(self.tcx);
4276 for obligation in ok.obligations {
4277 fulfill.register_predicate_obligation(self, obligation);
4279 fulfill.select_where_possible(self)
4283 Err(_) => return Err(()),
4286 // Record all the argument types, with the substitutions
4287 // produced from the above subtyping unification.
4288 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4290 .unwrap_or_default();
4292 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4293 formal_args, formal_ret, expect_args, expected_ret
4298 pub fn check_struct_path(
4302 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4303 let path_span = match *qpath {
4304 QPath::Resolved(_, ref path) => path.span,
4305 QPath::TypeRelative(ref qself, _) => qself.span,
4307 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4308 let variant = match def {
4310 self.set_tainted_by_errors();
4313 Res::Def(DefKind::Variant, _) => match ty.kind {
4314 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4315 _ => bug!("unexpected type: {:?}", ty),
4317 Res::Def(DefKind::Struct, _)
4318 | Res::Def(DefKind::Union, _)
4319 | Res::Def(DefKind::TyAlias, _)
4320 | Res::Def(DefKind::AssocTy, _)
4321 | Res::SelfTy(..) => match ty.kind {
4322 ty::Adt(adt, substs) if !adt.is_enum() => {
4323 Some((adt.non_enum_variant(), adt.did, substs))
4327 _ => bug!("unexpected definition: {:?}", def),
4330 if let Some((variant, did, substs)) = variant {
4331 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4332 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4334 // Check bounds on type arguments used in the path.
4335 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4337 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4338 self.add_obligations_for_parameters(cause, &bounds);
4346 "expected struct, variant or union type, found {}",
4347 ty.sort_string(self.tcx)
4349 .span_label(path_span, "not a struct")
4355 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4356 // The newly resolved definition is written into `type_dependent_defs`.
4357 fn finish_resolving_struct_path(
4362 ) -> (Res, Ty<'tcx>) {
4364 QPath::Resolved(ref maybe_qself, ref path) => {
4365 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4366 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4369 QPath::TypeRelative(ref qself, ref segment) => {
4370 let ty = self.to_ty(qself);
4372 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4378 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4379 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4380 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4382 // Write back the new resolution.
4383 self.write_resolution(hir_id, result);
4385 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4390 /// Resolves an associated value path into a base type and associated constant, or method
4391 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4392 pub fn resolve_ty_and_res_ufcs<'b>(
4394 qpath: &'b QPath<'b>,
4397 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4398 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4399 let (ty, qself, item_segment) = match *qpath {
4400 QPath::Resolved(ref opt_qself, ref path) => {
4403 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4407 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4409 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4410 // Return directly on cache hit. This is useful to avoid doubly reporting
4411 // errors with default match binding modes. See #44614.
4413 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4414 return (def, Some(ty), slice::from_ref(&**item_segment));
4416 let item_name = item_segment.ident;
4417 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4418 let result = match error {
4419 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4420 _ => Err(ErrorReported),
4422 if item_name.name != kw::Invalid {
4423 self.report_method_error(
4427 SelfSource::QPath(qself),
4431 .map(|mut e| e.emit());
4436 // Write back the new resolution.
4437 self.write_resolution(hir_id, result);
4439 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4441 slice::from_ref(&**item_segment),
4445 pub fn check_decl_initializer(
4447 local: &'tcx hir::Local<'tcx>,
4448 init: &'tcx hir::Expr<'tcx>,
4450 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4451 // for #42640 (default match binding modes).
4454 let ref_bindings = local.pat.contains_explicit_ref_binding();
4456 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4457 if let Some(m) = ref_bindings {
4458 // Somewhat subtle: if we have a `ref` binding in the pattern,
4459 // we want to avoid introducing coercions for the RHS. This is
4460 // both because it helps preserve sanity and, in the case of
4461 // ref mut, for soundness (issue #23116). In particular, in
4462 // the latter case, we need to be clear that the type of the
4463 // referent for the reference that results is *equal to* the
4464 // type of the place it is referencing, and not some
4465 // supertype thereof.
4466 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4467 self.demand_eqtype(init.span, local_ty, init_ty);
4470 self.check_expr_coercable_to_type(init, local_ty)
4474 /// Type check a `let` statement.
4475 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4476 // Determine and write the type which we'll check the pattern against.
4477 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4478 self.write_ty(local.hir_id, ty);
4480 // Type check the initializer.
4481 if let Some(ref init) = local.init {
4482 let init_ty = self.check_decl_initializer(local, &init);
4483 self.overwrite_local_ty_if_err(local, ty, init_ty);
4486 // Does the expected pattern type originate from an expression and what is the span?
4487 let (origin_expr, ty_span) = match (local.ty, local.init) {
4488 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4489 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4490 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4493 // Type check the pattern. Override if necessary to avoid knock-on errors.
4494 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4495 let pat_ty = self.node_ty(local.pat.hir_id);
4496 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4499 fn overwrite_local_ty_if_err(
4501 local: &'tcx hir::Local<'tcx>,
4505 if ty.references_error() {
4506 // Override the types everywhere with `types.err` to avoid knock on errors.
4507 self.write_ty(local.hir_id, ty);
4508 self.write_ty(local.pat.hir_id, ty);
4509 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4510 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4511 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4515 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4516 err.span_suggestion_short(
4517 span.shrink_to_hi(),
4518 "consider using a semicolon here",
4520 Applicability::MachineApplicable,
4524 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4525 // Don't do all the complex logic below for `DeclItem`.
4527 hir::StmtKind::Item(..) => return,
4528 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4531 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4533 // Hide the outer diverging and `has_errors` flags.
4534 let old_diverges = self.diverges.replace(Diverges::Maybe);
4535 let old_has_errors = self.has_errors.replace(false);
4538 hir::StmtKind::Local(ref l) => {
4539 self.check_decl_local(&l);
4542 hir::StmtKind::Item(_) => {}
4543 hir::StmtKind::Expr(ref expr) => {
4544 // Check with expected type of `()`.
4545 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4546 self.suggest_semicolon_at_end(expr.span, err);
4549 hir::StmtKind::Semi(ref expr) => {
4550 self.check_expr(&expr);
4554 // Combine the diverging and `has_error` flags.
4555 self.diverges.set(self.diverges.get() | old_diverges);
4556 self.has_errors.set(self.has_errors.get() | old_has_errors);
4559 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4560 let unit = self.tcx.mk_unit();
4561 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4563 // if the block produces a `!` value, that can always be
4564 // (effectively) coerced to unit.
4566 self.demand_suptype(blk.span, unit, ty);
4570 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4571 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4572 /// when given code like the following:
4574 /// if false { return 0i32; } else { 1u32 }
4575 /// // ^^^^ point at this instead of the whole `if` expression
4577 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4578 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4579 let arm_spans: Vec<Span> = arms
4582 self.in_progress_tables
4583 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4584 .and_then(|arm_ty| {
4585 if arm_ty.is_never() {
4588 Some(match &arm.body.kind {
4589 // Point at the tail expression when possible.
4590 hir::ExprKind::Block(block, _) => {
4591 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4599 if arm_spans.len() == 1 {
4600 return arm_spans[0];
4606 fn check_block_with_expected(
4608 blk: &'tcx hir::Block<'tcx>,
4609 expected: Expectation<'tcx>,
4612 let mut fcx_ps = self.ps.borrow_mut();
4613 let unsafety_state = fcx_ps.recurse(blk);
4614 replace(&mut *fcx_ps, unsafety_state)
4617 // In some cases, blocks have just one exit, but other blocks
4618 // can be targeted by multiple breaks. This can happen both
4619 // with labeled blocks as well as when we desugar
4620 // a `try { ... }` expression.
4624 // 'a: { if true { break 'a Err(()); } Ok(()) }
4626 // Here we would wind up with two coercions, one from
4627 // `Err(())` and the other from the tail expression
4628 // `Ok(())`. If the tail expression is omitted, that's a
4629 // "forced unit" -- unless the block diverges, in which
4630 // case we can ignore the tail expression (e.g., `'a: {
4631 // break 'a 22; }` would not force the type of the block
4633 let tail_expr = blk.expr.as_ref();
4634 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4635 let coerce = if blk.targeted_by_break {
4636 CoerceMany::new(coerce_to_ty)
4638 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4639 Some(e) => slice::from_ref(e),
4642 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4645 let prev_diverges = self.diverges.get();
4646 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4648 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4649 for s in blk.stmts {
4653 // check the tail expression **without** holding the
4654 // `enclosing_breakables` lock below.
4655 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4657 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4658 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4659 let coerce = ctxt.coerce.as_mut().unwrap();
4660 if let Some(tail_expr_ty) = tail_expr_ty {
4661 let tail_expr = tail_expr.unwrap();
4662 let span = self.get_expr_coercion_span(tail_expr);
4663 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4664 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4666 // Subtle: if there is no explicit tail expression,
4667 // that is typically equivalent to a tail expression
4668 // of `()` -- except if the block diverges. In that
4669 // case, there is no value supplied from the tail
4670 // expression (assuming there are no other breaks,
4671 // this implies that the type of the block will be
4674 // #41425 -- label the implicit `()` as being the
4675 // "found type" here, rather than the "expected type".
4676 if !self.diverges.get().is_always() {
4677 // #50009 -- Do not point at the entire fn block span, point at the return type
4678 // span, as it is the cause of the requirement, and
4679 // `consider_hint_about_removing_semicolon` will point at the last expression
4680 // if it were a relevant part of the error. This improves usability in editors
4681 // that highlight errors inline.
4682 let mut sp = blk.span;
4683 let mut fn_span = None;
4684 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4685 let ret_sp = decl.output.span();
4686 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4687 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4688 // output would otherwise be incorrect and even misleading. Make sure
4689 // the span we're aiming at correspond to a `fn` body.
4690 if block_sp == blk.span {
4692 fn_span = Some(ident.span);
4696 coerce.coerce_forced_unit(
4700 if let Some(expected_ty) = expected.only_has_type(self) {
4701 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4703 if let Some(fn_span) = fn_span {
4706 "implicitly returns `()` as its body has no tail or `return` \
4718 // If we can break from the block, then the block's exit is always reachable
4719 // (... as long as the entry is reachable) - regardless of the tail of the block.
4720 self.diverges.set(prev_diverges);
4723 let mut ty = ctxt.coerce.unwrap().complete(self);
4725 if self.has_errors.get() || ty.references_error() {
4726 ty = self.tcx.types.err
4729 self.write_ty(blk.hir_id, ty);
4731 *self.ps.borrow_mut() = prev;
4735 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4736 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4738 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4739 | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
4740 let body = self.tcx.hir().body(body_id);
4741 if let ExprKind::Block(block, _) = &body.value.kind {
4742 return Some(block.span);
4750 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4751 fn get_parent_fn_decl(
4754 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident)> {
4755 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4756 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4759 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4760 fn get_node_fn_decl(
4763 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident, bool)> {
4765 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4766 // This is less than ideal, it will not suggest a return type span on any
4767 // method called `main`, regardless of whether it is actually the entry point,
4768 // but it will still present it as the reason for the expected type.
4769 Some((&sig.decl, ident, ident.name != sym::main))
4771 Node::TraitItem(&hir::TraitItem {
4773 kind: hir::TraitItemKind::Fn(ref sig, ..),
4775 }) => Some((&sig.decl, ident, true)),
4776 Node::ImplItem(&hir::ImplItem {
4778 kind: hir::ImplItemKind::Fn(ref sig, ..),
4780 }) => Some((&sig.decl, ident, false)),
4785 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4786 /// suggestion can be made, `None` otherwise.
4787 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4788 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4789 // `while` before reaching it, as block tail returns are not available in them.
4790 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4791 let parent = self.tcx.hir().get(blk_id);
4792 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4796 /// On implicit return expressions with mismatched types, provides the following suggestions:
4798 /// - Points out the method's return type as the reason for the expected type.
4799 /// - Possible missing semicolon.
4800 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4801 pub fn suggest_mismatched_types_on_tail(
4803 err: &mut DiagnosticBuilder<'_>,
4804 expr: &'tcx hir::Expr<'tcx>,
4810 let expr = expr.peel_drop_temps();
4811 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4812 let mut pointing_at_return_type = false;
4813 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4814 pointing_at_return_type =
4815 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4817 pointing_at_return_type
4820 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4821 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4823 /// fn foo(x: usize) -> usize { x }
4824 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4828 err: &mut DiagnosticBuilder<'_>,
4829 expr: &hir::Expr<'_>,
4833 let hir = self.tcx.hir();
4834 let (def_id, sig) = match found.kind {
4835 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4836 ty::Closure(def_id, substs) => {
4837 // We don't use `closure_sig` to account for malformed closures like
4838 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4839 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4842 match closure_sig_ty.kind {
4843 ty::FnPtr(sig) => sig,
4851 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4852 let sig = self.normalize_associated_types_in(expr.span, &sig);
4853 if self.can_coerce(sig.output(), expected) {
4854 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4855 (String::new(), Applicability::MachineApplicable)
4857 ("...".to_string(), Applicability::HasPlaceholders)
4859 let mut msg = "call this function";
4860 match hir.get_if_local(def_id) {
4861 Some(Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. }))
4862 | Some(Node::ImplItem(hir::ImplItem {
4863 kind: hir::ImplItemKind::Fn(_, body_id),
4866 | Some(Node::TraitItem(hir::TraitItem {
4867 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Provided(body_id)),
4870 let body = hir.body(*body_id);
4874 .map(|param| match ¶m.pat.kind {
4875 hir::PatKind::Binding(_, _, ident, None)
4876 if ident.name != kw::SelfLower =>
4880 _ => "_".to_string(),
4882 .collect::<Vec<_>>()
4885 Some(Node::Expr(hir::Expr {
4886 kind: ExprKind::Closure(_, _, body_id, _, _),
4887 span: full_closure_span,
4890 if *full_closure_span == expr.span {
4893 msg = "call this closure";
4894 let body = hir.body(*body_id);
4898 .map(|param| match ¶m.pat.kind {
4899 hir::PatKind::Binding(_, _, ident, None)
4900 if ident.name != kw::SelfLower =>
4904 _ => "_".to_string(),
4906 .collect::<Vec<_>>()
4909 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4910 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4911 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4912 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4913 msg = "instantiate this tuple variant";
4915 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4916 msg = "instantiate this tuple struct";
4921 Some(Node::ForeignItem(hir::ForeignItem {
4922 kind: hir::ForeignItemKind::Fn(_, idents, _),
4928 if ident.name != kw::SelfLower {
4934 .collect::<Vec<_>>()
4937 Some(Node::TraitItem(hir::TraitItem {
4938 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Required(idents)),
4944 if ident.name != kw::SelfLower {
4950 .collect::<Vec<_>>()
4955 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4956 err.span_suggestion(
4958 &format!("use parentheses to {}", msg),
4959 format!("{}({})", code, sugg_call),
4968 pub fn suggest_ref_or_into(
4970 err: &mut DiagnosticBuilder<'_>,
4971 expr: &hir::Expr<'_>,
4975 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4976 err.span_suggestion(sp, msg, suggestion, Applicability::MachineApplicable);
4977 } else if let (ty::FnDef(def_id, ..), true) =
4978 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
4980 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4981 let sp = self.sess().source_map().def_span(sp);
4982 err.span_label(sp, &format!("{} defined here", found));
4984 } else if !self.check_for_cast(err, expr, found, expected) {
4985 let is_struct_pat_shorthand_field =
4986 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
4987 let methods = self.get_conversion_methods(expr.span, expected, found);
4988 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4989 let mut suggestions = iter::repeat(&expr_text)
4990 .zip(methods.iter())
4991 .filter_map(|(receiver, method)| {
4992 let method_call = format!(".{}()", method.ident);
4993 if receiver.ends_with(&method_call) {
4994 None // do not suggest code that is already there (#53348)
4996 let method_call_list = [".to_vec()", ".to_string()"];
4997 let sugg = if receiver.ends_with(".clone()")
4998 && method_call_list.contains(&method_call.as_str())
5000 let max_len = receiver.rfind('.').unwrap();
5001 format!("{}{}", &receiver[..max_len], method_call)
5003 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
5004 format!("({}){}", receiver, method_call)
5006 format!("{}{}", receiver, method_call)
5009 Some(if is_struct_pat_shorthand_field {
5010 format!("{}: {}", receiver, sugg)
5017 if suggestions.peek().is_some() {
5018 err.span_suggestions(
5020 "try using a conversion method",
5022 Applicability::MaybeIncorrect,
5029 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
5030 /// in the heap by calling `Box::new()`.
5031 fn suggest_boxing_when_appropriate(
5033 err: &mut DiagnosticBuilder<'_>,
5034 expr: &hir::Expr<'_>,
5038 if self.tcx.hir().is_const_context(expr.hir_id) {
5039 // Do not suggest `Box::new` in const context.
5042 if !expected.is_box() || found.is_box() {
5045 let boxed_found = self.tcx.mk_box(found);
5046 if let (true, Ok(snippet)) = (
5047 self.can_coerce(boxed_found, expected),
5048 self.sess().source_map().span_to_snippet(expr.span),
5050 err.span_suggestion(
5052 "store this in the heap by calling `Box::new`",
5053 format!("Box::new({})", snippet),
5054 Applicability::MachineApplicable,
5057 "for more on the distinction between the stack and the heap, read \
5058 https://doc.rust-lang.org/book/ch15-01-box.html, \
5059 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
5060 https://doc.rust-lang.org/std/boxed/index.html",
5065 /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
5066 fn suggest_calling_boxed_future_when_appropriate(
5068 err: &mut DiagnosticBuilder<'_>,
5069 expr: &hir::Expr<'_>,
5075 if self.tcx.hir().is_const_context(expr.hir_id) {
5076 // Do not suggest `Box::new` in const context.
5079 let pin_did = self.tcx.lang_items().pin_type();
5080 match expected.kind {
5081 ty::Adt(def, _) if Some(def.did) != pin_did => return false,
5082 // This guards the `unwrap` and `mk_box` below.
5083 _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
5086 let boxed_found = self.tcx.mk_box(found);
5087 let new_found = self.tcx.mk_lang_item(boxed_found, lang_items::PinTypeLangItem).unwrap();
5088 if let (true, Ok(snippet)) = (
5089 self.can_coerce(new_found, expected),
5090 self.sess().source_map().span_to_snippet(expr.span),
5093 ty::Adt(def, _) if def.is_box() => {
5094 err.help("use `Box::pin`");
5097 err.span_suggestion(
5099 "you need to pin and box this expression",
5100 format!("Box::pin({})", snippet),
5101 Applicability::MachineApplicable,
5111 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5115 /// bar_that_returns_u32()
5119 /// This routine checks if the return expression in a block would make sense on its own as a
5120 /// statement and the return type has been left as default or has been specified as `()`. If so,
5121 /// it suggests adding a semicolon.
5122 fn suggest_missing_semicolon(
5124 err: &mut DiagnosticBuilder<'_>,
5125 expression: &'tcx hir::Expr<'tcx>,
5129 if expected.is_unit() {
5130 // `BlockTailExpression` only relevant if the tail expr would be
5131 // useful on its own.
5132 match expression.kind {
5134 | ExprKind::MethodCall(..)
5135 | ExprKind::Loop(..)
5136 | ExprKind::Match(..)
5137 | ExprKind::Block(..) => {
5138 err.span_suggestion(
5139 cause_span.shrink_to_hi(),
5140 "try adding a semicolon",
5142 Applicability::MachineApplicable,
5150 /// A possible error is to forget to add a return type that is needed:
5154 /// bar_that_returns_u32()
5158 /// This routine checks if the return type is left as default, the method is not part of an
5159 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5161 fn suggest_missing_return_type(
5163 err: &mut DiagnosticBuilder<'_>,
5164 fn_decl: &hir::FnDecl<'_>,
5169 // Only suggest changing the return type for methods that
5170 // haven't set a return type at all (and aren't `fn main()` or an impl).
5171 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5172 (&hir::FnRetTy::DefaultReturn(span), true, true, true) => {
5173 err.span_suggestion(
5175 "try adding a return type",
5176 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5177 Applicability::MachineApplicable,
5181 (&hir::FnRetTy::DefaultReturn(span), false, true, true) => {
5182 err.span_label(span, "possibly return type missing here?");
5185 (&hir::FnRetTy::DefaultReturn(span), _, false, true) => {
5186 // `fn main()` must return `()`, do not suggest changing return type
5187 err.span_label(span, "expected `()` because of default return type");
5190 // expectation was caused by something else, not the default return
5191 (&hir::FnRetTy::DefaultReturn(_), _, _, false) => false,
5192 (&hir::FnRetTy::Return(ref ty), _, _, _) => {
5193 // Only point to return type if the expected type is the return type, as if they
5194 // are not, the expectation must have been caused by something else.
5195 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5197 let ty = AstConv::ast_ty_to_ty(self, ty);
5198 debug!("suggest_missing_return_type: return type {:?}", ty);
5199 debug!("suggest_missing_return_type: expected type {:?}", ty);
5200 if ty.kind == expected.kind {
5201 err.span_label(sp, format!("expected `{}` because of return type", expected));
5209 /// A possible error is to forget to add `.await` when using futures:
5212 /// async fn make_u32() -> u32 {
5216 /// fn take_u32(x: u32) {}
5218 /// async fn foo() {
5219 /// let x = make_u32();
5224 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5225 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5226 /// `.await` to the tail of the expression.
5227 fn suggest_missing_await(
5229 err: &mut DiagnosticBuilder<'_>,
5230 expr: &hir::Expr<'_>,
5234 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5235 // body isn't `async`.
5236 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5237 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5238 let body = self.tcx().hir().body(body_id);
5239 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5241 // Check for `Future` implementations by constructing a predicate to
5242 // prove: `<T as Future>::Output == U`
5243 let future_trait = self.tcx.lang_items().future_trait().unwrap();
5244 let item_def_id = self
5246 .associated_items(future_trait)
5247 .in_definition_order()
5252 ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5253 // `<T as Future>::Output`
5254 projection_ty: ty::ProjectionTy {
5256 substs: self.tcx.mk_substs_trait(
5258 self.fresh_substs_for_item(sp, item_def_id),
5265 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5266 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5267 if self.infcx.predicate_may_hold(&obligation) {
5268 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5269 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5270 err.span_suggestion(
5272 "consider using `.await` here",
5273 format!("{}.await", code),
5274 Applicability::MaybeIncorrect,
5277 debug!("suggest_missing_await: no snippet for {:?}", sp);
5280 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5286 /// A common error is to add an extra semicolon:
5289 /// fn foo() -> usize {
5294 /// This routine checks if the final statement in a block is an
5295 /// expression with an explicit semicolon whose type is compatible
5296 /// with `expected_ty`. If so, it suggests removing the semicolon.
5297 fn consider_hint_about_removing_semicolon(
5299 blk: &'tcx hir::Block<'tcx>,
5300 expected_ty: Ty<'tcx>,
5301 err: &mut DiagnosticBuilder<'_>,
5303 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5304 err.span_suggestion(
5306 "consider removing this semicolon",
5308 Applicability::MachineApplicable,
5313 fn could_remove_semicolon(
5315 blk: &'tcx hir::Block<'tcx>,
5316 expected_ty: Ty<'tcx>,
5318 // Be helpful when the user wrote `{... expr;}` and
5319 // taking the `;` off is enough to fix the error.
5320 let last_stmt = blk.stmts.last()?;
5321 let last_expr = match last_stmt.kind {
5322 hir::StmtKind::Semi(ref e) => e,
5325 let last_expr_ty = self.node_ty(last_expr.hir_id);
5326 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5329 let original_span = original_sp(last_stmt.span, blk.span);
5330 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5333 // Instantiates the given path, which must refer to an item with the given
5334 // number of type parameters and type.
5335 pub fn instantiate_value_path(
5337 segments: &[hir::PathSegment<'_>],
5338 self_ty: Option<Ty<'tcx>>,
5342 ) -> (Ty<'tcx>, Res) {
5344 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5345 segments, self_ty, res, hir_id,
5350 let path_segs = match res {
5351 Res::Local(_) | Res::SelfCtor(_) => vec![],
5352 Res::Def(kind, def_id) => {
5353 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5355 _ => bug!("instantiate_value_path on {:?}", res),
5358 let mut user_self_ty = None;
5359 let mut is_alias_variant_ctor = false;
5361 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5362 if let Some(self_ty) = self_ty {
5363 let adt_def = self_ty.ty_adt_def().unwrap();
5364 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5365 is_alias_variant_ctor = true;
5368 Res::Def(DefKind::AssocFn, def_id) | Res::Def(DefKind::AssocConst, def_id) => {
5369 let container = tcx.associated_item(def_id).container;
5370 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5372 ty::TraitContainer(trait_did) => {
5373 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5375 ty::ImplContainer(impl_def_id) => {
5376 if segments.len() == 1 {
5377 // `<T>::assoc` will end up here, and so
5378 // can `T::assoc`. It this came from an
5379 // inherent impl, we need to record the
5380 // `T` for posterity (see `UserSelfTy` for
5382 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5383 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5391 // Now that we have categorized what space the parameters for each
5392 // segment belong to, let's sort out the parameters that the user
5393 // provided (if any) into their appropriate spaces. We'll also report
5394 // errors if type parameters are provided in an inappropriate place.
5396 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5397 let generics_has_err = AstConv::prohibit_generics(
5399 segments.iter().enumerate().filter_map(|(index, seg)| {
5400 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5408 if let Res::Local(hid) = res {
5409 let ty = self.local_ty(span, hid).decl_ty;
5410 let ty = self.normalize_associated_types_in(span, &ty);
5411 self.write_ty(hir_id, ty);
5415 if generics_has_err {
5416 // Don't try to infer type parameters when prohibited generic arguments were given.
5417 user_self_ty = None;
5420 // Now we have to compare the types that the user *actually*
5421 // provided against the types that were *expected*. If the user
5422 // did not provide any types, then we want to substitute inference
5423 // variables. If the user provided some types, we may still need
5424 // to add defaults. If the user provided *too many* types, that's
5427 let mut infer_args_for_err = FxHashSet::default();
5428 for &PathSeg(def_id, index) in &path_segs {
5429 let seg = &segments[index];
5430 let generics = tcx.generics_of(def_id);
5431 // Argument-position `impl Trait` is treated as a normal generic
5432 // parameter internally, but we don't allow users to specify the
5433 // parameter's value explicitly, so we have to do some error-
5435 if let Err(GenericArgCountMismatch { reported: Some(ErrorReported), .. }) =
5436 AstConv::check_generic_arg_count_for_call(
5437 tcx, span, &generics, &seg, false, // `is_method_call`
5440 infer_args_for_err.insert(index);
5441 self.set_tainted_by_errors(); // See issue #53251.
5445 let has_self = path_segs
5447 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5450 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5451 let ty = self.normalize_ty(span, tcx.at(span).type_of(impl_def_id));
5453 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5454 let variant = adt_def.non_enum_variant();
5455 let ctor_def_id = variant.ctor_def_id.unwrap();
5457 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5462 let mut err = tcx.sess.struct_span_err(
5464 "the `Self` constructor can only be used with tuple or unit structs",
5466 if let Some(adt_def) = ty.ty_adt_def() {
5467 match adt_def.adt_kind() {
5469 err.help("did you mean to use one of the enum's variants?");
5471 AdtKind::Struct | AdtKind::Union => {
5472 err.span_suggestion(
5474 "use curly brackets",
5475 String::from("Self { /* fields */ }"),
5476 Applicability::HasPlaceholders,
5483 return (tcx.types.err, res);
5489 let def_id = res.def_id();
5491 // The things we are substituting into the type should not contain
5492 // escaping late-bound regions, and nor should the base type scheme.
5493 let ty = tcx.type_of(def_id);
5495 let substs = self_ctor_substs.unwrap_or_else(|| {
5496 AstConv::create_substs_for_generic_args(
5502 infer_args_for_err.is_empty(),
5503 // Provide the generic args, and whether types should be inferred.
5505 if let Some(&PathSeg(_, index)) =
5506 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5508 // If we've encountered an `impl Trait`-related error, we're just
5509 // going to infer the arguments for better error messages.
5510 if !infer_args_for_err.contains(&index) {
5511 // Check whether the user has provided generic arguments.
5512 if let Some(ref data) = segments[index].args {
5513 return (Some(data), segments[index].infer_args);
5516 return (None, segments[index].infer_args);
5521 // Provide substitutions for parameters for which (valid) arguments have been provided.
5522 |param, arg| match (¶m.kind, arg) {
5523 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5524 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5526 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5527 self.to_ty(ty).into()
5529 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5530 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5532 _ => unreachable!(),
5534 // Provide substitutions for parameters for which arguments are inferred.
5535 |substs, param, infer_args| {
5537 GenericParamDefKind::Lifetime => {
5538 self.re_infer(Some(param), span).unwrap().into()
5540 GenericParamDefKind::Type { has_default, .. } => {
5541 if !infer_args && has_default {
5542 // If we have a default, then we it doesn't matter that we're not
5543 // inferring the type arguments: we provide the default where any
5545 let default = tcx.type_of(param.def_id);
5548 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5552 // If no type arguments were provided, we have to infer them.
5553 // This case also occurs as a result of some malformed input, e.g.
5554 // a lifetime argument being given instead of a type parameter.
5555 // Using inference instead of `Error` gives better error messages.
5556 self.var_for_def(span, param)
5559 GenericParamDefKind::Const => {
5560 // FIXME(const_generics:defaults)
5561 // No const parameters were provided, we have to infer them.
5562 self.var_for_def(span, param)
5568 assert!(!substs.has_escaping_bound_vars());
5569 assert!(!ty.has_escaping_bound_vars());
5571 // First, store the "user substs" for later.
5572 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5574 self.add_required_obligations(span, def_id, &substs);
5576 // Substitute the values for the type parameters into the type of
5577 // the referenced item.
5578 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5580 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5581 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5582 // is inherent, there is no `Self` parameter; instead, the impl needs
5583 // type parameters, which we can infer by unifying the provided `Self`
5584 // with the substituted impl type.
5585 // This also occurs for an enum variant on a type alias.
5586 let ty = tcx.type_of(impl_def_id);
5588 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5589 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5590 Ok(ok) => self.register_infer_ok_obligations(ok),
5592 self.tcx.sess.delay_span_bug(span, &format!(
5593 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5601 self.check_rustc_args_require_const(def_id, hir_id, span);
5603 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5604 self.write_substs(hir_id, substs);
5606 (ty_substituted, res)
5609 /// Add all the obligations that are required, substituting and normalized appropriately.
5610 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5611 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5613 for (i, mut obligation) in traits::predicates_for_generics(
5614 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5621 // This makes the error point at the bound, but we want to point at the argument
5622 if let Some(span) = spans.get(i) {
5623 obligation.cause.code = traits::BindingObligation(def_id, *span);
5625 self.register_predicate(obligation);
5629 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5630 // We're only interested in functions tagged with
5631 // #[rustc_args_required_const], so ignore anything that's not.
5632 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5636 // If our calling expression is indeed the function itself, we're good!
5637 // If not, generate an error that this can only be called directly.
5638 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5639 if let ExprKind::Call(ref callee, ..) = expr.kind {
5640 if callee.hir_id == hir_id {
5646 self.tcx.sess.span_err(
5648 "this function can only be invoked directly, not through a function pointer",
5652 /// Resolves `typ` by a single level if `typ` is a type variable.
5653 /// If no resolution is possible, then an error is reported.
5654 /// Numeric inference variables may be left unresolved.
5655 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5656 let ty = self.resolve_vars_with_obligations(ty);
5657 if !ty.is_ty_var() {
5660 if !self.is_tainted_by_errors() {
5661 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5662 .note("type must be known at this point")
5665 self.demand_suptype(sp, self.tcx.types.err, ty);
5670 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5673 ctxt: BreakableCtxt<'tcx>,
5675 ) -> (BreakableCtxt<'tcx>, R) {
5678 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5679 index = enclosing_breakables.stack.len();
5680 enclosing_breakables.by_id.insert(id, index);
5681 enclosing_breakables.stack.push(ctxt);
5685 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5686 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5687 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5688 enclosing_breakables.stack.pop().expect("missing breakable context")
5693 /// Instantiate a QueryResponse in a probe context, without a
5694 /// good ObligationCause.
5695 fn probe_instantiate_query_response(
5698 original_values: &OriginalQueryValues<'tcx>,
5699 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5700 ) -> InferResult<'tcx, Ty<'tcx>> {
5701 self.instantiate_query_response_and_region_obligations(
5702 &traits::ObligationCause::misc(span, self.body_id),
5709 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5710 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5711 let mut contained_in_place = false;
5713 while let hir::Node::Expr(parent_expr) =
5714 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5716 match &parent_expr.kind {
5717 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5718 if lhs.hir_id == expr_id {
5719 contained_in_place = true;
5725 expr_id = parent_expr.hir_id;
5732 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5733 let own_counts = generics.own_counts();
5735 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5736 own_counts.types, own_counts.consts, ty
5739 if own_counts.types == 0 {
5743 // Make a vector of booleans initially `false`; set to `true` when used.
5744 let mut types_used = vec![false; own_counts.types];
5746 for leaf_ty in ty.walk() {
5747 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5748 debug!("found use of ty param num {}", index);
5749 types_used[index as usize - own_counts.lifetimes] = true;
5750 } else if let ty::Error = leaf_ty.kind {
5751 // If there is already another error, do not emit
5752 // an error for not using a type parameter.
5753 assert!(tcx.sess.has_errors());
5758 let types = generics.params.iter().filter(|param| match param.kind {
5759 ty::GenericParamDefKind::Type { .. } => true,
5762 for (&used, param) in types_used.iter().zip(types) {
5764 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5765 let span = tcx.hir().span(id);
5766 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5767 .span_label(span, "unused type parameter")
5773 fn fatally_break_rust(sess: &Session) {
5774 let handler = sess.diagnostic();
5775 handler.span_bug_no_panic(
5777 "It looks like you're trying to break rust; would you like some ICE?",
5779 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5780 handler.note_without_error(
5781 "we would appreciate a joke overview: \
5782 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5784 handler.note_without_error(&format!(
5785 "rustc {} running on {}",
5786 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5787 config::host_triple(),
5791 fn potentially_plural_count(count: usize, word: &str) -> String {
5792 format!("{} {}{}", count, word, pluralize!(count))