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};
92 use rustc_ast::util::parser::ExprPrecedence;
93 use rustc_attr as attr;
94 use rustc_data_structures::captures::Captures;
95 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
96 use rustc_errors::ErrorReported;
97 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
99 use rustc_hir::def::{CtorOf, DefKind, Res};
100 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId, LOCAL_CRATE};
101 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
102 use rustc_hir::itemlikevisit::ItemLikeVisitor;
103 use rustc_hir::lang_items;
104 use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath};
105 use rustc_index::bit_set::BitSet;
106 use rustc_index::vec::Idx;
107 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
108 use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
109 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
110 use rustc_infer::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
111 use rustc_infer::infer::{self, InferCtxt, InferOk, InferResult, TyCtxtInferExt};
112 use rustc_middle::hir::map::blocks::FnLikeNode;
113 use rustc_middle::middle::region;
114 use rustc_middle::mir::interpret::ConstValue;
115 use rustc_middle::ty::adjustment::{
116 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast,
118 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
119 use rustc_middle::ty::query::Providers;
120 use rustc_middle::ty::subst::{
121 GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSelfTy, UserSubsts,
123 use rustc_middle::ty::util::{Discr, IntTypeExt, Representability};
124 use rustc_middle::ty::{
125 self, AdtKind, CanonicalUserType, Const, GenericParamDefKind, RegionKind, ToPolyTraitRef,
126 ToPredicate, Ty, TyCtxt, UserType, WithConstness,
128 use rustc_session::config::{self, EntryFnType};
129 use rustc_session::lint;
130 use rustc_session::parse::feature_err;
131 use rustc_session::Session;
132 use rustc_span::hygiene::DesugaringKind;
133 use rustc_span::source_map::{original_sp, DUMMY_SP};
134 use rustc_span::symbol::{kw, sym, Ident};
135 use rustc_span::{self, BytePos, MultiSpan, Span};
136 use rustc_target::abi::VariantIdx;
137 use rustc_target::spec::abi::Abi;
138 use rustc_trait_selection::infer::InferCtxtExt as _;
139 use rustc_trait_selection::opaque_types::{InferCtxtExt as _, OpaqueTypeDecl};
140 use rustc_trait_selection::traits::error_reporting::recursive_type_with_infinite_size_error;
141 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
142 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
143 use rustc_trait_selection::traits::{
144 self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt,
147 use std::cell::{Cell, Ref, RefCell, RefMut};
149 use std::collections::hash_map::Entry;
151 use std::mem::replace;
152 use std::ops::{self, Deref};
155 use crate::require_c_abi_if_c_variadic;
156 use crate::util::common::indenter;
158 use self::autoderef::Autoderef;
159 use self::callee::DeferredCallResolution;
160 use self::coercion::{CoerceMany, DynamicCoerceMany};
161 use self::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
162 use self::method::{MethodCallee, SelfSource};
163 pub use self::Expectation::*;
164 use self::TupleArgumentsFlag::*;
167 macro_rules! type_error_struct {
168 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
169 if $typ.references_error() {
170 $session.diagnostic().struct_dummy()
172 rustc_errors::struct_span_err!($session, $span, $code, $($message)*)
177 /// The type of a local binding, including the revealed type for anon types.
178 #[derive(Copy, Clone, Debug)]
179 pub struct LocalTy<'tcx> {
181 revealed_ty: Ty<'tcx>,
184 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
185 #[derive(Copy, Clone)]
186 struct MaybeInProgressTables<'a, 'tcx> {
187 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
190 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
191 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
192 match self.maybe_tables {
193 Some(tables) => tables.borrow(),
194 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables"),
198 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
199 match self.maybe_tables {
200 Some(tables) => tables.borrow_mut(),
201 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables"),
206 /// Closures defined within the function. For example:
209 /// bar(move|| { ... })
212 /// Here, the function `foo()` and the closure passed to
213 /// `bar()` will each have their own `FnCtxt`, but they will
214 /// share the inherited fields.
215 pub struct Inherited<'a, 'tcx> {
216 infcx: InferCtxt<'a, 'tcx>,
218 tables: MaybeInProgressTables<'a, 'tcx>,
220 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
222 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
224 // Some additional `Sized` obligations badly affect type inference.
225 // These obligations are added in a later stage of typeck.
226 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
228 // When we process a call like `c()` where `c` is a closure type,
229 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
230 // `FnOnce` closure. In that case, we defer full resolution of the
231 // call until upvar inference can kick in and make the
232 // decision. We keep these deferred resolutions grouped by the
233 // def-id of the closure, so that once we decide, we can easily go
234 // back and process them.
235 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
237 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
239 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
241 // Opaque types found in explicit return types and their
242 // associated fresh inference variable. Writeback resolves these
243 // variables to get the concrete type, which can be used to
244 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
245 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
247 /// A map from inference variables created from opaque
248 /// type instantiations (`ty::Infer`) to the actual opaque
249 /// type (`ty::Opaque`). Used during fallback to map unconstrained
250 /// opaque type inference variables to their corresponding
252 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
254 /// Each type parameter has an implicit region bound that
255 /// indicates it must outlive at least the function body (the user
256 /// may specify stronger requirements). This field indicates the
257 /// region of the callee. If it is `None`, then the parameter
258 /// environment is for an item or something where the "callee" is
260 implicit_region_bound: Option<ty::Region<'tcx>>,
262 body_id: Option<hir::BodyId>,
265 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
266 type Target = InferCtxt<'a, 'tcx>;
267 fn deref(&self) -> &Self::Target {
272 /// When type-checking an expression, we propagate downward
273 /// whatever type hint we are able in the form of an `Expectation`.
274 #[derive(Copy, Clone, Debug)]
275 pub enum Expectation<'tcx> {
276 /// We know nothing about what type this expression should have.
279 /// This expression should have the type given (or some subtype).
280 ExpectHasType(Ty<'tcx>),
282 /// This expression will be cast to the `Ty`.
283 ExpectCastableToType(Ty<'tcx>),
285 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
286 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
287 ExpectRvalueLikeUnsized(Ty<'tcx>),
290 impl<'a, 'tcx> Expectation<'tcx> {
291 // Disregard "castable to" expectations because they
292 // can lead us astray. Consider for example `if cond
293 // {22} else {c} as u8` -- if we propagate the
294 // "castable to u8" constraint to 22, it will pick the
295 // type 22u8, which is overly constrained (c might not
296 // be a u8). In effect, the problem is that the
297 // "castable to" expectation is not the tightest thing
298 // we can say, so we want to drop it in this case.
299 // The tightest thing we can say is "must unify with
300 // else branch". Note that in the case of a "has type"
301 // constraint, this limitation does not hold.
303 // If the expected type is just a type variable, then don't use
304 // an expected type. Otherwise, we might write parts of the type
305 // when checking the 'then' block which are incompatible with the
307 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
309 ExpectHasType(ety) => {
310 let ety = fcx.shallow_resolve(ety);
311 if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
313 ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
318 /// Provides an expectation for an rvalue expression given an *optional*
319 /// hint, which is not required for type safety (the resulting type might
320 /// be checked higher up, as is the case with `&expr` and `box expr`), but
321 /// is useful in determining the concrete type.
323 /// The primary use case is where the expected type is a fat pointer,
324 /// like `&[isize]`. For example, consider the following statement:
326 /// let x: &[isize] = &[1, 2, 3];
328 /// In this case, the expected type for the `&[1, 2, 3]` expression is
329 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
330 /// expectation `ExpectHasType([isize])`, that would be too strong --
331 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
332 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
333 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
334 /// which still is useful, because it informs integer literals and the like.
335 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
336 /// for examples of where this comes up,.
337 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
338 match fcx.tcx.struct_tail_without_normalization(ty).kind {
339 ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
340 _ => ExpectHasType(ty),
344 // Resolves `expected` by a single level if it is a variable. If
345 // there is no expected type or resolution is not possible (e.g.,
346 // no constraints yet present), just returns `None`.
347 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
349 NoExpectation => NoExpectation,
350 ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
351 ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
352 ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
356 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
357 match self.resolve(fcx) {
358 NoExpectation => None,
359 ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
363 /// It sometimes happens that we want to turn an expectation into
364 /// a **hard constraint** (i.e., something that must be satisfied
365 /// for the program to type-check). `only_has_type` will return
366 /// such a constraint, if it exists.
367 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
368 match self.resolve(fcx) {
369 ExpectHasType(ty) => Some(ty),
370 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
374 /// Like `only_has_type`, but instead of returning `None` if no
375 /// hard constraint exists, creates a fresh type variable.
376 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
377 self.only_has_type(fcx).unwrap_or_else(|| {
378 fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
383 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
390 fn maybe_mut_place(m: hir::Mutability) -> Self {
392 hir::Mutability::Mut => Needs::MutPlace,
393 hir::Mutability::Not => Needs::None,
398 #[derive(Copy, Clone)]
399 pub struct UnsafetyState {
401 pub unsafety: hir::Unsafety,
402 pub unsafe_push_count: u32,
407 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
408 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
411 pub fn recurse(&mut self, blk: &hir::Block<'_>) -> UnsafetyState {
412 use hir::BlockCheckMode;
413 match self.unsafety {
414 // If this unsafe, then if the outer function was already marked as
415 // unsafe we shouldn't attribute the unsafe'ness to the block. This
416 // way the block can be warned about instead of ignoring this
417 // extraneous block (functions are never warned about).
418 hir::Unsafety::Unsafe if self.from_fn => *self,
421 let (unsafety, def, count) = match blk.rules {
422 BlockCheckMode::PushUnsafeBlock(..) => {
423 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
425 BlockCheckMode::PopUnsafeBlock(..) => {
426 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
428 BlockCheckMode::UnsafeBlock(..) => {
429 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
431 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
433 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
439 #[derive(Debug, Copy, Clone)]
445 /// Tracks whether executing a node may exit normally (versus
446 /// return/break/panic, which "diverge", leaving dead code in their
447 /// wake). Tracked semi-automatically (through type variables marked
448 /// as diverging), with some manual adjustments for control-flow
449 /// primitives (approximating a CFG).
450 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
452 /// Potentially unknown, some cases converge,
453 /// others require a CFG to determine them.
456 /// Definitely known to diverge and therefore
457 /// not reach the next sibling or its parent.
459 /// The `Span` points to the expression
460 /// that caused us to diverge
461 /// (e.g. `return`, `break`, etc).
463 /// In some cases (e.g. a `match` expression
464 /// where all arms diverge), we may be
465 /// able to provide a more informative
466 /// message to the user.
467 /// If this is `None`, a default message
468 /// will be generated, which is suitable
470 custom_note: Option<&'static str>,
473 /// Same as `Always` but with a reachability
474 /// warning already emitted.
478 // Convenience impls for combining `Diverges`.
480 impl ops::BitAnd for Diverges {
482 fn bitand(self, other: Self) -> Self {
483 cmp::min(self, other)
487 impl ops::BitOr for Diverges {
489 fn bitor(self, other: Self) -> Self {
490 cmp::max(self, other)
494 impl ops::BitAndAssign for Diverges {
495 fn bitand_assign(&mut self, other: Self) {
496 *self = *self & other;
500 impl ops::BitOrAssign for Diverges {
501 fn bitor_assign(&mut self, other: Self) {
502 *self = *self | other;
507 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
508 fn always(span: Span) -> Diverges {
509 Diverges::Always { span, custom_note: None }
512 fn is_always(self) -> bool {
513 // Enum comparison ignores the
514 // contents of fields, so we just
515 // fill them in with garbage here.
516 self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
520 pub struct BreakableCtxt<'tcx> {
523 // this is `null` for loops where break with a value is illegal,
524 // such as `while`, `for`, and `while let`
525 coerce: Option<DynamicCoerceMany<'tcx>>,
528 pub struct EnclosingBreakables<'tcx> {
529 stack: Vec<BreakableCtxt<'tcx>>,
530 by_id: HirIdMap<usize>,
533 impl<'tcx> EnclosingBreakables<'tcx> {
534 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
535 self.opt_find_breakable(target_id).unwrap_or_else(|| {
536 bug!("could not find enclosing breakable with id {}", target_id);
540 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
541 match self.by_id.get(&target_id) {
542 Some(ix) => Some(&mut self.stack[*ix]),
548 pub struct FnCtxt<'a, 'tcx> {
551 /// The parameter environment used for proving trait obligations
552 /// in this function. This can change when we descend into
553 /// closures (as they bring new things into scope), hence it is
554 /// not part of `Inherited` (as of the time of this writing,
555 /// closures do not yet change the environment, but they will
557 param_env: ty::ParamEnv<'tcx>,
559 /// Number of errors that had been reported when we started
560 /// checking this function. On exit, if we find that *more* errors
561 /// have been reported, we will skip regionck and other work that
562 /// expects the types within the function to be consistent.
563 // FIXME(matthewjasper) This should not exist, and it's not correct
564 // if type checking is run in parallel.
565 err_count_on_creation: usize,
567 /// If `Some`, this stores coercion information for returned
568 /// expressions. If `None`, this is in a context where return is
569 /// inappropriate, such as a const expression.
571 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
572 /// can track all the return expressions and then use them to
573 /// compute a useful coercion from the set, similar to a match
574 /// expression or other branching context. You can use methods
575 /// like `expected_ty` to access the declared return type (if
577 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
579 /// First span of a return site that we find. Used in error messages.
580 ret_coercion_span: RefCell<Option<Span>>,
582 resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>,
584 ps: RefCell<UnsafetyState>,
586 /// Whether the last checked node generates a divergence (e.g.,
587 /// `return` will set this to `Always`). In general, when entering
588 /// an expression or other node in the tree, the initial value
589 /// indicates whether prior parts of the containing expression may
590 /// have diverged. It is then typically set to `Maybe` (and the
591 /// old value remembered) for processing the subparts of the
592 /// current expression. As each subpart is processed, they may set
593 /// the flag to `Always`, etc. Finally, at the end, we take the
594 /// result and "union" it with the original value, so that when we
595 /// return the flag indicates if any subpart of the parent
596 /// expression (up to and including this part) has diverged. So,
597 /// if you read it after evaluating a subexpression `X`, the value
598 /// you get indicates whether any subexpression that was
599 /// evaluating up to and including `X` diverged.
601 /// We currently use this flag only for diagnostic purposes:
603 /// - To warn about unreachable code: if, after processing a
604 /// sub-expression but before we have applied the effects of the
605 /// current node, we see that the flag is set to `Always`, we
606 /// can issue a warning. This corresponds to something like
607 /// `foo(return)`; we warn on the `foo()` expression. (We then
608 /// update the flag to `WarnedAlways` to suppress duplicate
609 /// reports.) Similarly, if we traverse to a fresh statement (or
610 /// tail expression) from a `Always` setting, we will issue a
611 /// warning. This corresponds to something like `{return;
612 /// foo();}` or `{return; 22}`, where we would warn on the
615 /// An expression represents dead code if, after checking it,
616 /// the diverges flag is set to something other than `Maybe`.
617 diverges: Cell<Diverges>,
619 /// Whether any child nodes have any type errors.
620 has_errors: Cell<bool>,
622 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
624 inh: &'a Inherited<'a, 'tcx>,
627 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
628 type Target = Inherited<'a, 'tcx>;
629 fn deref(&self) -> &Self::Target {
634 /// Helper type of a temporary returned by `Inherited::build(...)`.
635 /// Necessary because we can't write the following bound:
636 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
637 pub struct InheritedBuilder<'tcx> {
638 infcx: infer::InferCtxtBuilder<'tcx>,
642 impl Inherited<'_, 'tcx> {
643 pub fn build(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> InheritedBuilder<'tcx> {
644 let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
647 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_owner),
653 impl<'tcx> InheritedBuilder<'tcx> {
654 fn enter<F, R>(&mut self, f: F) -> R
656 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
658 let def_id = self.def_id;
659 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
663 impl Inherited<'a, 'tcx> {
664 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
666 let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
667 let body_id = tcx.hir().maybe_body_owned_by(item_id);
668 let implicit_region_bound = body_id.map(|body_id| {
669 let body = tcx.hir().body(body_id);
670 tcx.mk_region(ty::ReScope(region::Scope {
671 id: body.value.hir_id.local_id,
672 data: region::ScopeData::CallSite,
677 tables: MaybeInProgressTables { maybe_tables: infcx.in_progress_tables },
679 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
680 locals: RefCell::new(Default::default()),
681 deferred_sized_obligations: RefCell::new(Vec::new()),
682 deferred_call_resolutions: RefCell::new(Default::default()),
683 deferred_cast_checks: RefCell::new(Vec::new()),
684 deferred_generator_interiors: RefCell::new(Vec::new()),
685 opaque_types: RefCell::new(Default::default()),
686 opaque_types_vars: RefCell::new(Default::default()),
687 implicit_region_bound,
692 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
693 debug!("register_predicate({:?})", obligation);
694 if obligation.has_escaping_bound_vars() {
695 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
697 self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
700 fn register_predicates<I>(&self, obligations: I)
702 I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
704 for obligation in obligations {
705 self.register_predicate(obligation);
709 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
710 self.register_predicates(infer_ok.obligations);
714 fn normalize_associated_types_in<T>(
718 param_env: ty::ParamEnv<'tcx>,
722 T: TypeFoldable<'tcx>,
724 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
725 self.register_infer_ok_obligations(ok)
729 struct CheckItemTypesVisitor<'tcx> {
733 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
734 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
735 check_item_type(self.tcx, i);
737 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
738 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
741 pub fn check_wf_new(tcx: TyCtxt<'_>) {
742 let visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
743 tcx.hir().krate().par_visit_all_item_likes(&visit);
746 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
747 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
750 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
751 debug_assert!(crate_num == LOCAL_CRATE);
752 tcx.par_body_owners(|body_owner_def_id| {
753 tcx.ensure().typeck_tables_of(body_owner_def_id.to_def_id());
757 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
758 wfcheck::check_item_well_formed(tcx, def_id);
761 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
762 wfcheck::check_trait_item(tcx, def_id);
765 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
766 wfcheck::check_impl_item(tcx, def_id);
769 pub fn provide(providers: &mut Providers<'_>) {
770 method::provide(providers);
771 *providers = Providers {
774 diagnostic_only_typeck_tables_of,
778 check_item_well_formed,
779 check_trait_item_well_formed,
780 check_impl_item_well_formed,
781 check_mod_item_types,
786 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
787 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
790 /// If this `DefId` is a "primary tables entry", returns
791 /// `Some((body_id, header, decl))` with information about
792 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
795 /// If this function returns `Some`, then `typeck_tables(def_id)` will
796 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
797 /// may not succeed. In some cases where this function returns `None`
798 /// (notably closures), `typeck_tables(def_id)` would wind up
799 /// redirecting to the owning function.
803 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
804 match tcx.hir().get(id) {
805 Node::Item(item) => match item.kind {
806 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
807 Some((body, Some(ty), None, None))
809 hir::ItemKind::Fn(ref sig, .., body) => {
810 Some((body, None, Some(&sig.header), Some(&sig.decl)))
814 Node::TraitItem(item) => match item.kind {
815 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
816 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
817 Some((body, None, Some(&sig.header), Some(&sig.decl)))
821 Node::ImplItem(item) => match item.kind {
822 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
823 hir::ImplItemKind::Fn(ref sig, body) => {
824 Some((body, None, Some(&sig.header), Some(&sig.decl)))
828 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
833 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
834 // Closures' tables come from their outermost function,
835 // as they are part of the same "inference environment".
836 let outer_def_id = tcx.closure_base_def_id(def_id);
837 if outer_def_id != def_id {
838 return tcx.has_typeck_tables(outer_def_id);
841 // FIXME(#71104) Should really be using just `as_local_hir_id` but
842 // some `LocalDefId` do not seem to have a corresponding HirId.
844 def_id.as_local().and_then(|def_id| tcx.hir().opt_local_def_id_to_hir_id(def_id))
846 primary_body_of(tcx, id).is_some()
852 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
853 &*tcx.typeck_tables_of(def_id).used_trait_imports
856 /// Inspects the substs of opaque types, replacing any inference variables
857 /// with proper generic parameter from the identity substs.
859 /// This is run after we normalize the function signature, to fix any inference
860 /// variables introduced by the projection of associated types. This ensures that
861 /// any opaque types used in the signature continue to refer to generic parameters,
862 /// allowing them to be considered for defining uses in the function body
864 /// For example, consider this code.
869 /// fn use_it(self) -> Self::MyItem
871 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
872 /// type MyItem = impl Iterator<Item = I>;
873 /// fn use_it(self) -> Self::MyItem {
879 /// When we normalize the signature of `use_it` from the impl block,
880 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
881 /// However, this projection result may contain inference variables, due
882 /// to the way that projection works. We didn't have any inference variables
883 /// in the signature to begin with - leaving them in will cause us to incorrectly
884 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
885 /// variables back to the actual generic parameters, we will correctly see that
886 /// we have a defining use of `MyItem`
887 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
889 T: TypeFoldable<'tcx>,
891 struct FixupFolder<'tcx> {
895 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
896 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
900 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
902 ty::Opaque(def_id, substs) => {
903 debug!("fixup_opaque_types: found type {:?}", ty);
904 // Here, we replace any inference variables that occur within
905 // the substs of an opaque type. By definition, any type occurring
906 // in the substs has a corresponding generic parameter, which is what
907 // we replace it with.
908 // This replacement is only run on the function signature, so any
909 // inference variables that we come across must be the rust of projection
910 // (there's no other way for a user to get inference variables into
911 // a function signature).
912 if ty.needs_infer() {
913 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
914 let old_param = substs[param.index as usize];
915 match old_param.unpack() {
916 GenericArgKind::Type(old_ty) => {
917 if let ty::Infer(_) = old_ty.kind {
918 // Replace inference type with a generic parameter
919 self.tcx.mk_param_from_def(param)
921 old_param.fold_with(self)
924 GenericArgKind::Const(old_const) => {
925 if let ty::ConstKind::Infer(_) = old_const.val {
926 // This should never happen - we currently do not support
927 // 'const projections', e.g.:
928 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
929 // which should be the only way for us to end up with a const inference
930 // variable after projection. If Rust ever gains support for this kind
931 // of projection, this should *probably* be changed to
932 // `self.tcx.mk_param_from_def(param)`
934 "Found infer const: `{:?}` in opaque type: {:?}",
939 old_param.fold_with(self)
942 GenericArgKind::Lifetime(old_region) => {
943 if let RegionKind::ReVar(_) = old_region {
944 self.tcx.mk_param_from_def(param)
946 old_param.fold_with(self)
951 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
952 debug!("fixup_opaque_types: new type: {:?}", new_ty);
958 _ => ty.super_fold_with(self),
963 debug!("fixup_opaque_types({:?})", val);
964 val.fold_with(&mut FixupFolder { tcx })
967 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &ty::TypeckTables<'tcx> {
968 let fallback = move || tcx.type_of(def_id);
969 typeck_tables_of_with_fallback(tcx, def_id, fallback)
972 /// Used only to get `TypeckTables` for type inference during error recovery.
973 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
974 fn diagnostic_only_typeck_tables_of<'tcx>(
977 ) -> &ty::TypeckTables<'tcx> {
978 assert!(def_id.is_local());
979 let fallback = move || {
980 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id).unwrap());
981 tcx.sess.delay_span_bug(span, "diagnostic only typeck table used");
984 typeck_tables_of_with_fallback(tcx, def_id, fallback)
987 fn typeck_tables_of_with_fallback<'tcx>(
990 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
991 ) -> &'tcx ty::TypeckTables<'tcx> {
992 // Closures' tables come from their outermost function,
993 // as they are part of the same "inference environment".
994 let outer_def_id = tcx.closure_base_def_id(def_id);
995 if outer_def_id != def_id {
996 return tcx.typeck_tables_of(outer_def_id);
999 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
1000 let span = tcx.hir().span(id);
1002 // Figure out what primary body this item has.
1003 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
1004 span_bug!(span, "can't type-check body of {:?}", def_id);
1006 let body = tcx.hir().body(body_id);
1008 let tables = Inherited::build(tcx, def_id.expect_local()).enter(|inh| {
1009 let param_env = tcx.param_env(def_id);
1010 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1011 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1012 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1018 &hir::Generics::empty(),
1025 check_abi(tcx, span, fn_sig.abi());
1027 // Compute the fty from point of view of inside the fn.
1028 let fn_sig = tcx.liberate_late_bound_regions(def_id, &fn_sig);
1029 let fn_sig = inh.normalize_associated_types_in(
1036 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1038 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1041 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1042 let expected_type = body_ty
1043 .and_then(|ty| match ty.kind {
1044 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1047 .unwrap_or_else(fallback);
1048 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1049 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1051 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1052 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1057 // Gather locals in statics (because of block expressions).
1058 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1060 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1062 fcx.write_ty(id, revealed_ty);
1067 // All type checking constraints were added, try to fallback unsolved variables.
1068 fcx.select_obligations_where_possible(false, |_| {});
1069 let mut fallback_has_occurred = false;
1071 // We do fallback in two passes, to try to generate
1072 // better error messages.
1073 // The first time, we do *not* replace opaque types.
1074 for ty in &fcx.unsolved_variables() {
1075 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1077 // We now see if we can make progress. This might
1078 // cause us to unify inference variables for opaque types,
1079 // since we may have unified some other type variables
1080 // during the first phase of fallback.
1081 // This means that we only replace inference variables with their underlying
1082 // opaque types as a last resort.
1084 // In code like this:
1087 // type MyType = impl Copy;
1088 // fn produce() -> MyType { true }
1089 // fn bad_produce() -> MyType { panic!() }
1092 // we want to unify the opaque inference variable in `bad_produce`
1093 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1094 // This will produce a nice error message about conflicting concrete
1095 // types for `MyType`.
1097 // If we had tried to fallback the opaque inference variable to `MyType`,
1098 // we will generate a confusing type-check error that does not explicitly
1099 // refer to opaque types.
1100 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1102 // We now run fallback again, but this time we allow it to replace
1103 // unconstrained opaque type variables, in addition to performing
1104 // other kinds of fallback.
1105 for ty in &fcx.unsolved_variables() {
1106 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1109 // See if we can make any more progress.
1110 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1112 // Even though coercion casts provide type hints, we check casts after fallback for
1113 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1116 // Closure and generator analysis may run after fallback
1117 // because they don't constrain other type variables.
1118 fcx.closure_analyze(body);
1119 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1120 fcx.resolve_generator_interiors(def_id);
1122 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1123 let ty = fcx.normalize_ty(span, ty);
1124 fcx.require_type_is_sized(ty, span, code);
1127 fcx.select_all_obligations_or_error();
1129 if fn_decl.is_some() {
1130 fcx.regionck_fn(id, body);
1132 fcx.regionck_expr(body);
1135 fcx.resolve_type_vars_in_body(body)
1138 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1139 // it will need to hold.
1140 assert_eq!(tables.hir_owner, Some(id.owner));
1145 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1146 if !tcx.sess.target.target.is_abi_supported(abi) {
1151 "The ABI `{}` is not supported for the current target",
1158 struct GatherLocalsVisitor<'a, 'tcx> {
1159 fcx: &'a FnCtxt<'a, 'tcx>,
1160 parent_id: hir::HirId,
1163 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1164 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1167 // Infer the variable's type.
1168 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1169 kind: TypeVariableOriginKind::TypeInference,
1175 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1179 // Take type that the user specified.
1180 self.fcx.locals.borrow_mut().insert(nid, typ);
1187 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1188 type Map = intravisit::ErasedMap<'tcx>;
1190 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
1191 NestedVisitorMap::None
1194 // Add explicitly-declared locals.
1195 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1196 let local_ty = match local.ty {
1198 let o_ty = self.fcx.to_ty(&ty);
1200 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1201 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1210 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1212 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1213 ty.hir_id, o_ty, revealed_ty, c_ty
1215 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1217 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1221 self.assign(local.span, local.hir_id, local_ty);
1224 "local variable {:?} is assigned type {}",
1226 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&local.hir_id).unwrap().decl_ty)
1228 intravisit::walk_local(self, local);
1231 // Add pattern bindings.
1232 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1233 if let PatKind::Binding(_, _, ident, _) = p.kind {
1234 let var_ty = self.assign(p.span, p.hir_id, None);
1236 if !self.fcx.tcx.features().unsized_locals {
1237 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1241 "pattern binding {} is assigned to {} with type {:?}",
1243 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&p.hir_id).unwrap().decl_ty),
1247 intravisit::walk_pat(self, p);
1250 // Don't descend into the bodies of nested closures.
1253 _: intravisit::FnKind<'tcx>,
1254 _: &'tcx hir::FnDecl<'tcx>,
1262 /// When `check_fn` is invoked on a generator (i.e., a body that
1263 /// includes yield), it returns back some information about the yield
1265 struct GeneratorTypes<'tcx> {
1266 /// Type of generator argument / values returned by `yield`.
1267 resume_ty: Ty<'tcx>,
1269 /// Type of value that is yielded.
1272 /// Types that are captured (see `GeneratorInterior` for more).
1275 /// Indicates if the generator is movable or static (immovable).
1276 movability: hir::Movability,
1279 /// Helper used for fns and closures. Does the grungy work of checking a function
1280 /// body and returns the function context used for that purpose, since in the case of a fn item
1281 /// there is still a bit more to do.
1284 /// * inherited: other fields inherited from the enclosing fn (if any)
1285 fn check_fn<'a, 'tcx>(
1286 inherited: &'a Inherited<'a, 'tcx>,
1287 param_env: ty::ParamEnv<'tcx>,
1288 fn_sig: ty::FnSig<'tcx>,
1289 decl: &'tcx hir::FnDecl<'tcx>,
1291 body: &'tcx hir::Body<'tcx>,
1292 can_be_generator: Option<hir::Movability>,
1293 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1294 let mut fn_sig = fn_sig;
1296 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1298 // Create the function context. This is either derived from scratch or,
1299 // in the case of closures, based on the outer context.
1300 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1301 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1304 let sess = tcx.sess;
1305 let hir = tcx.hir();
1307 let declared_ret_ty = fn_sig.output();
1308 let revealed_ret_ty =
1309 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1310 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1311 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1312 fn_sig = tcx.mk_fn_sig(
1313 fn_sig.inputs().iter().cloned(),
1320 let span = body.value.span;
1322 fn_maybe_err(tcx, span, fn_sig.abi);
1324 if body.generator_kind.is_some() && can_be_generator.is_some() {
1326 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1327 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1329 // Resume type defaults to `()` if the generator has no argument.
1330 let resume_ty = fn_sig.inputs().get(0).copied().unwrap_or_else(|| tcx.mk_unit());
1332 fcx.resume_yield_tys = Some((resume_ty, yield_ty));
1335 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id));
1336 let outer_hir_id = hir.as_local_hir_id(outer_def_id).unwrap();
1337 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1339 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1340 // (as it's created inside the body itself, not passed in from outside).
1341 let maybe_va_list = if fn_sig.c_variadic {
1342 let va_list_did = tcx.require_lang_item(
1343 lang_items::VaListTypeLangItem,
1344 Some(body.params.last().unwrap().span),
1346 let region = tcx.mk_region(ty::ReScope(region::Scope {
1347 id: body.value.hir_id.local_id,
1348 data: region::ScopeData::CallSite,
1351 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1356 // Add formal parameters.
1357 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1358 let inputs_fn = fn_sig.inputs().iter().copied();
1359 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1360 // Check the pattern.
1361 fcx.check_pat_top(¶m.pat, param_ty, try { inputs_hir?.get(idx)?.span }, false);
1363 // Check that argument is Sized.
1364 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1365 // for simple cases like `fn foo(x: Trait)`,
1366 // where we would error once on the parameter as a whole, and once on the binding `x`.
1367 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1368 fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType);
1371 fcx.write_ty(param.hir_id, param_ty);
1374 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1376 if let ty::Dynamic(..) = declared_ret_ty.kind {
1377 // FIXME: We need to verify that the return type is `Sized` after the return expression has
1378 // been evaluated so that we have types available for all the nodes being returned, but that
1379 // requires the coerced evaluated type to be stored. Moving `check_return_expr` before this
1380 // causes unsized errors caused by the `declared_ret_ty` to point at the return expression,
1381 // while keeping the current ordering we will ignore the tail expression's type because we
1382 // don't know it yet. We can't do `check_expr_kind` while keeping `check_return_expr`
1383 // because we will trigger "unreachable expression" lints unconditionally.
1384 // Because of all of this, we perform a crude check to know whether the simplest `!Sized`
1385 // case that a newcomer might make, returning a bare trait, and in that case we populate
1386 // the tail expression's type so that the suggestion will be correct, but ignore all other
1388 fcx.check_expr(&body.value);
1389 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1390 tcx.sess.delay_span_bug(decl.output.span(), "`!Sized` return type");
1392 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1393 fcx.check_return_expr(&body.value);
1396 // We insert the deferred_generator_interiors entry after visiting the body.
1397 // This ensures that all nested generators appear before the entry of this generator.
1398 // resolve_generator_interiors relies on this property.
1399 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1401 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1402 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1404 let (resume_ty, yield_ty) = fcx.resume_yield_tys.unwrap();
1405 Some(GeneratorTypes {
1409 movability: can_be_generator.unwrap(),
1415 // Finalize the return check by taking the LUB of the return types
1416 // we saw and assigning it to the expected return type. This isn't
1417 // really expected to fail, since the coercions would have failed
1418 // earlier when trying to find a LUB.
1420 // However, the behavior around `!` is sort of complex. In the
1421 // event that the `actual_return_ty` comes back as `!`, that
1422 // indicates that the fn either does not return or "returns" only
1423 // values of type `!`. In this case, if there is an expected
1424 // return type that is *not* `!`, that should be ok. But if the
1425 // return type is being inferred, we want to "fallback" to `!`:
1427 // let x = move || panic!();
1429 // To allow for that, I am creating a type variable with diverging
1430 // fallback. This was deemed ever so slightly better than unifying
1431 // the return value with `!` because it allows for the caller to
1432 // make more assumptions about the return type (e.g., they could do
1434 // let y: Option<u32> = Some(x());
1436 // which would then cause this return type to become `u32`, not
1438 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1439 let mut actual_return_ty = coercion.complete(&fcx);
1440 if actual_return_ty.is_never() {
1441 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1442 kind: TypeVariableOriginKind::DivergingFn,
1446 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1448 // Check that the main return type implements the termination trait.
1449 if let Some(term_id) = tcx.lang_items().termination() {
1450 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1451 let main_id = hir.as_local_hir_id(def_id).unwrap();
1452 if main_id == fn_id {
1453 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1454 let trait_ref = ty::TraitRef::new(term_id, substs);
1455 let return_ty_span = decl.output.span();
1456 let cause = traits::ObligationCause::new(
1459 ObligationCauseCode::MainFunctionType,
1462 inherited.register_predicate(traits::Obligation::new(
1465 trait_ref.without_const().to_predicate(),
1471 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1472 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1473 if panic_impl_did == hir.local_def_id(fn_id) {
1474 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1475 if declared_ret_ty.kind != ty::Never {
1476 sess.span_err(decl.output.span(), "return type should be `!`");
1479 let inputs = fn_sig.inputs();
1480 let span = hir.span(fn_id);
1481 if inputs.len() == 1 {
1482 let arg_is_panic_info = match inputs[0].kind {
1483 ty::Ref(region, ty, mutbl) => match ty.kind {
1484 ty::Adt(ref adt, _) => {
1485 adt.did == panic_info_did
1486 && mutbl == hir::Mutability::Not
1487 && *region != RegionKind::ReStatic
1494 if !arg_is_panic_info {
1495 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1498 if let Node::Item(item) = hir.get(fn_id) {
1499 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1500 if !generics.params.is_empty() {
1501 sess.span_err(span, "should have no type parameters");
1506 let span = sess.source_map().guess_head_span(span);
1507 sess.span_err(span, "function should have one argument");
1510 sess.err("language item required, but not found: `panic_info`");
1515 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1516 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1517 if alloc_error_handler_did == hir.local_def_id(fn_id) {
1518 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1519 if declared_ret_ty.kind != ty::Never {
1520 sess.span_err(decl.output.span(), "return type should be `!`");
1523 let inputs = fn_sig.inputs();
1524 let span = hir.span(fn_id);
1525 if inputs.len() == 1 {
1526 let arg_is_alloc_layout = match inputs[0].kind {
1527 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1531 if !arg_is_alloc_layout {
1532 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1535 if let Node::Item(item) = hir.get(fn_id) {
1536 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1537 if !generics.params.is_empty() {
1540 "`#[alloc_error_handler]` function should have no type \
1547 let span = sess.source_map().guess_head_span(span);
1548 sess.span_err(span, "function should have one argument");
1551 sess.err("language item required, but not found: `alloc_layout`");
1559 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1560 let def_id = tcx.hir().local_def_id(id);
1561 let def = tcx.adt_def(def_id);
1562 def.destructor(tcx); // force the destructor to be evaluated
1563 check_representable(tcx, span, def_id);
1565 if def.repr.simd() {
1566 check_simd(tcx, span, def_id);
1569 check_transparent(tcx, span, def_id);
1570 check_packed(tcx, span, def_id);
1573 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1574 let def_id = tcx.hir().local_def_id(id);
1575 let def = tcx.adt_def(def_id);
1576 def.destructor(tcx); // force the destructor to be evaluated
1577 check_representable(tcx, span, def_id);
1578 check_transparent(tcx, span, def_id);
1579 check_union_fields(tcx, span, def_id);
1580 check_packed(tcx, span, def_id);
1583 /// When the `#![feature(untagged_unions)]` gate is active,
1584 /// check that the fields of the `union` does not contain fields that need dropping.
1585 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1586 let item_type = tcx.type_of(item_def_id);
1587 if let ty::Adt(def, substs) = item_type.kind {
1588 assert!(def.is_union());
1589 let fields = &def.non_enum_variant().fields;
1590 let param_env = tcx.param_env(item_def_id);
1591 for field in fields {
1592 let field_ty = field.ty(tcx, substs);
1593 // We are currently checking the type this field came from, so it must be local.
1594 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1595 if field_ty.needs_drop(tcx, param_env) {
1600 "unions may not contain fields that need dropping"
1602 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1608 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1613 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1614 /// projections that would result in "inheriting lifetimes".
1615 fn check_opaque<'tcx>(
1618 substs: SubstsRef<'tcx>,
1620 origin: &hir::OpaqueTyOrigin,
1622 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1623 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1626 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1627 /// in "inheriting lifetimes".
1628 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: Span) {
1630 tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1632 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1637 struct ProhibitOpaqueVisitor<'tcx> {
1638 opaque_identity_ty: Ty<'tcx>,
1639 generics: &'tcx ty::Generics,
1642 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1643 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1644 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1645 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1648 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1649 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1650 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1651 return *index < self.generics.parent_count as u32;
1654 r.super_visit_with(self)
1658 let prohibit_opaque = match item.kind {
1659 ItemKind::OpaqueTy(hir::OpaqueTy {
1660 origin: hir::OpaqueTyOrigin::AsyncFn | hir::OpaqueTyOrigin::FnReturn,
1663 let mut visitor = ProhibitOpaqueVisitor {
1664 opaque_identity_ty: tcx
1665 .mk_opaque(def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1666 generics: tcx.generics_of(def_id),
1668 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1670 tcx.predicates_of(def_id)
1673 .any(|(predicate, _)| predicate.visit_with(&mut visitor))
1678 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1679 if prohibit_opaque {
1680 let is_async = match item.kind {
1681 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1682 hir::OpaqueTyOrigin::AsyncFn => true,
1685 _ => unreachable!(),
1691 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1693 if is_async { "async fn" } else { "impl Trait" },
1699 /// Checks that an opaque type does not contain cycles.
1700 fn check_opaque_for_cycles<'tcx>(
1703 substs: SubstsRef<'tcx>,
1705 origin: &hir::OpaqueTyOrigin,
1707 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1708 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1709 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",)
1710 .span_label(span, "recursive `async fn`")
1711 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
1715 struct_span_err!(tcx.sess, span, E0720, "opaque type expands to a recursive type",);
1716 err.span_label(span, "expands to a recursive type");
1717 if let ty::Opaque(..) = partially_expanded_type.kind {
1718 err.note("type resolves to itself");
1720 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1727 // Forbid defining intrinsics in Rust code,
1728 // as they must always be defined by the compiler.
1729 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1730 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1731 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1735 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1737 "check_item_type(it.hir_id={}, it.name={})",
1739 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1741 let _indenter = indenter();
1743 // Consts can play a role in type-checking, so they are included here.
1744 hir::ItemKind::Static(..) => {
1745 let def_id = tcx.hir().local_def_id(it.hir_id);
1746 tcx.typeck_tables_of(def_id);
1747 maybe_check_static_with_link_section(tcx, def_id, it.span);
1749 hir::ItemKind::Const(..) => {
1750 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1752 hir::ItemKind::Enum(ref enum_definition, _) => {
1753 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1755 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1756 hir::ItemKind::Impl { ref items, .. } => {
1757 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1758 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1759 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1760 check_impl_items_against_trait(tcx, it.span, impl_def_id, impl_trait_ref, items);
1761 let trait_def_id = impl_trait_ref.def_id;
1762 check_on_unimplemented(tcx, trait_def_id, it);
1765 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1766 let def_id = tcx.hir().local_def_id(it.hir_id);
1767 check_on_unimplemented(tcx, def_id, it);
1769 for item in items.iter() {
1770 let item = tcx.hir().trait_item(item.id);
1771 if let hir::TraitItemKind::Fn(sig, _) = &item.kind {
1772 let abi = sig.header.abi;
1773 fn_maybe_err(tcx, item.ident.span, abi);
1777 hir::ItemKind::Struct(..) => {
1778 check_struct(tcx, it.hir_id, it.span);
1780 hir::ItemKind::Union(..) => {
1781 check_union(tcx, it.hir_id, it.span);
1783 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1784 let def_id = tcx.hir().local_def_id(it.hir_id);
1786 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1787 check_opaque(tcx, def_id, substs, it.span, &origin);
1789 hir::ItemKind::TyAlias(..) => {
1790 let def_id = tcx.hir().local_def_id(it.hir_id);
1791 let pty_ty = tcx.type_of(def_id);
1792 let generics = tcx.generics_of(def_id);
1793 check_type_params_are_used(tcx, &generics, pty_ty);
1795 hir::ItemKind::ForeignMod(ref m) => {
1796 check_abi(tcx, it.span, m.abi);
1798 if m.abi == Abi::RustIntrinsic {
1799 for item in m.items {
1800 intrinsic::check_intrinsic_type(tcx, item);
1802 } else if m.abi == Abi::PlatformIntrinsic {
1803 for item in m.items {
1804 intrinsic::check_platform_intrinsic_type(tcx, item);
1807 for item in m.items {
1808 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1809 let own_counts = generics.own_counts();
1810 if generics.params.len() - own_counts.lifetimes != 0 {
1811 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1812 (_, 0) => ("type", "types", Some("u32")),
1813 // We don't specify an example value, because we can't generate
1814 // a valid value for any type.
1815 (0, _) => ("const", "consts", None),
1816 _ => ("type or const", "types or consts", None),
1822 "foreign items may not have {} parameters",
1825 .span_label(item.span, &format!("can't have {} parameters", kinds))
1827 // FIXME: once we start storing spans for type arguments, turn this
1828 // into a suggestion.
1830 "replace the {} parameters with concrete {}{}",
1833 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1839 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1840 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1845 _ => { /* nothing to do */ }
1849 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1850 // Only restricted on wasm32 target for now
1851 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1855 // If `#[link_section]` is missing, then nothing to verify
1856 let attrs = tcx.codegen_fn_attrs(id);
1857 if attrs.link_section.is_none() {
1861 // For the wasm32 target statics with `#[link_section]` are placed into custom
1862 // sections of the final output file, but this isn't link custom sections of
1863 // other executable formats. Namely we can only embed a list of bytes,
1864 // nothing with pointers to anything else or relocations. If any relocation
1865 // show up, reject them here.
1866 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1867 // the consumer's responsibility to ensure all bytes that have been read
1868 // have defined values.
1869 match tcx.const_eval_poly(id) {
1870 Ok(ConstValue::ByRef { alloc, .. }) => {
1871 if alloc.relocations().len() != 0 {
1872 let msg = "statics with a custom `#[link_section]` must be a \
1873 simple list of bytes on the wasm target with no \
1874 extra levels of indirection such as references";
1875 tcx.sess.span_err(span, msg);
1878 Ok(_) => bug!("Matching on non-ByRef static"),
1883 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1884 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1885 // an error would be reported if this fails.
1886 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1889 fn report_forbidden_specialization(
1891 impl_item: &hir::ImplItem<'_>,
1894 let mut err = struct_span_err!(
1898 "`{}` specializes an item from a parent `impl`, but \
1899 that item is not marked `default`",
1902 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
1904 match tcx.span_of_impl(parent_impl) {
1906 err.span_label(span, "parent `impl` is here");
1908 "to specialize, `{}` in the parent `impl` must be marked `default`",
1913 err.note(&format!("parent implementation is in crate `{}`", cname));
1920 fn check_specialization_validity<'tcx>(
1922 trait_def: &ty::TraitDef,
1923 trait_item: &ty::AssocItem,
1925 impl_item: &hir::ImplItem<'_>,
1927 let kind = match impl_item.kind {
1928 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1929 hir::ImplItemKind::Fn(..) => ty::AssocKind::Fn,
1930 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1931 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1934 let ancestors = match trait_def.ancestors(tcx, impl_id) {
1935 Ok(ancestors) => ancestors,
1938 let mut ancestor_impls = ancestors
1940 .filter_map(|parent| {
1941 if parent.is_from_trait() {
1944 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1949 if ancestor_impls.peek().is_none() {
1950 // No parent, nothing to specialize.
1954 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1956 // Parent impl exists, and contains the parent item we're trying to specialize, but
1957 // doesn't mark it `default`.
1958 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1959 Some(Err(parent_impl.def_id()))
1962 // Parent impl contains item and makes it specializable.
1963 Some(_) => Some(Ok(())),
1965 // Parent impl doesn't mention the item. This means it's inherited from the
1966 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1967 // "defaultness" from the grandparent, else they are final.
1969 if tcx.impl_defaultness(parent_impl.def_id()).is_default() {
1972 Some(Err(parent_impl.def_id()))
1978 // If `opt_result` is `None`, we have only encountered `default impl`s that don't contain the
1979 // item. This is allowed, the item isn't actually getting specialized here.
1980 let result = opt_result.unwrap_or(Ok(()));
1982 if let Err(parent_impl) = result {
1983 report_forbidden_specialization(tcx, impl_item, parent_impl);
1987 fn check_impl_items_against_trait<'tcx>(
1989 full_impl_span: Span,
1991 impl_trait_ref: ty::TraitRef<'tcx>,
1992 impl_item_refs: &[hir::ImplItemRef<'_>],
1994 let impl_span = tcx.sess.source_map().guess_head_span(full_impl_span);
1996 // If the trait reference itself is erroneous (so the compilation is going
1997 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1998 // isn't populated for such impls.
1999 if impl_trait_ref.references_error() {
2003 // Negative impls are not expected to have any items
2004 match tcx.impl_polarity(impl_id) {
2005 ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
2006 ty::ImplPolarity::Negative => {
2007 if let [first_item_ref, ..] = impl_item_refs {
2008 let first_item_span = tcx.hir().impl_item(first_item_ref.id).span;
2013 "negative impls cannot have any items"
2021 // Locate trait definition and items
2022 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
2024 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
2026 // Check existing impl methods to see if they are both present in trait
2027 // and compatible with trait signature
2028 for impl_item in impl_items() {
2029 let namespace = impl_item.kind.namespace();
2030 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
2031 let ty_trait_item = tcx
2032 .associated_items(impl_trait_ref.def_id)
2033 .find_by_name_and_namespace(tcx, ty_impl_item.ident, namespace, impl_trait_ref.def_id)
2035 // Not compatible, but needed for the error message
2036 tcx.associated_items(impl_trait_ref.def_id)
2037 .filter_by_name(tcx, ty_impl_item.ident, impl_trait_ref.def_id)
2041 // Check that impl definition matches trait definition
2042 if let Some(ty_trait_item) = ty_trait_item {
2043 match impl_item.kind {
2044 hir::ImplItemKind::Const(..) => {
2045 // Find associated const definition.
2046 if ty_trait_item.kind == ty::AssocKind::Const {
2055 let mut err = struct_span_err!(
2059 "item `{}` is an associated const, \
2060 which doesn't match its trait `{}`",
2062 impl_trait_ref.print_only_trait_path()
2064 err.span_label(impl_item.span, "does not match trait");
2065 // We can only get the spans from local trait definition
2066 // Same for E0324 and E0325
2067 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2068 err.span_label(trait_span, "item in trait");
2073 hir::ImplItemKind::Fn(..) => {
2074 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2075 if ty_trait_item.kind == ty::AssocKind::Fn {
2076 compare_impl_method(
2085 let mut err = struct_span_err!(
2089 "item `{}` is an associated method, \
2090 which doesn't match its trait `{}`",
2092 impl_trait_ref.print_only_trait_path()
2094 err.span_label(impl_item.span, "does not match trait");
2095 if let Some(trait_span) = opt_trait_span {
2096 err.span_label(trait_span, "item in trait");
2101 hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {
2102 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2103 if ty_trait_item.kind == ty::AssocKind::Type {
2113 let mut err = struct_span_err!(
2117 "item `{}` is an associated type, \
2118 which doesn't match its trait `{}`",
2120 impl_trait_ref.print_only_trait_path()
2122 err.span_label(impl_item.span, "does not match trait");
2123 if let Some(trait_span) = opt_trait_span {
2124 err.span_label(trait_span, "item in trait");
2131 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2135 // Check for missing items from trait
2136 let mut missing_items = Vec::new();
2137 if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id) {
2138 for trait_item in tcx.associated_items(impl_trait_ref.def_id).in_definition_order() {
2139 let is_implemented = ancestors
2140 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2141 .map(|node_item| !node_item.defining_node.is_from_trait())
2144 if !is_implemented && tcx.impl_defaultness(impl_id).is_final() {
2145 if !trait_item.defaultness.has_value() {
2146 missing_items.push(*trait_item);
2152 if !missing_items.is_empty() {
2153 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2157 fn missing_items_err(
2160 missing_items: &[ty::AssocItem],
2161 full_impl_span: Span,
2163 let missing_items_msg = missing_items
2165 .map(|trait_item| trait_item.ident.to_string())
2166 .collect::<Vec<_>>()
2169 let mut err = struct_span_err!(
2173 "not all trait items implemented, missing: `{}`",
2176 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2178 // `Span` before impl block closing brace.
2179 let hi = full_impl_span.hi() - BytePos(1);
2180 // Point at the place right before the closing brace of the relevant `impl` to suggest
2181 // adding the associated item at the end of its body.
2182 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2183 // Obtain the level of indentation ending in `sugg_sp`.
2184 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2185 // Make the whitespace that will make the suggestion have the right indentation.
2186 let padding: String = (0..indentation).map(|_| " ").collect();
2188 for trait_item in missing_items {
2189 let snippet = suggestion_signature(&trait_item, tcx);
2190 let code = format!("{}{}\n{}", padding, snippet, padding);
2191 let msg = format!("implement the missing item: `{}`", snippet);
2192 let appl = Applicability::HasPlaceholders;
2193 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2194 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2195 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2197 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2203 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
2204 fn bounds_from_generic_predicates(
2206 predicates: ty::GenericPredicates<'_>,
2207 ) -> (String, String) {
2208 let mut types: FxHashMap<Ty<'_>, Vec<DefId>> = FxHashMap::default();
2209 let mut projections = vec![];
2210 for (predicate, _) in predicates.predicates {
2211 debug!("predicate {:?}", predicate);
2213 ty::Predicate::Trait(trait_predicate, _) => {
2214 let entry = types.entry(trait_predicate.skip_binder().self_ty()).or_default();
2215 let def_id = trait_predicate.skip_binder().def_id();
2216 if Some(def_id) != tcx.lang_items().sized_trait() {
2217 // Type params are `Sized` by default, do not add that restriction to the list
2218 // if it is a positive requirement.
2219 entry.push(trait_predicate.skip_binder().def_id());
2222 ty::Predicate::Projection(projection_pred) => {
2223 projections.push(projection_pred);
2228 let generics = if types.is_empty() {
2235 .filter_map(|t| match t.kind {
2236 ty::Param(_) => Some(t.to_string()),
2237 // Avoid suggesting the following:
2238 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
2241 .collect::<Vec<_>>()
2245 let mut where_clauses = vec![];
2246 for (ty, bounds) in types {
2247 for bound in &bounds {
2248 where_clauses.push(format!("{}: {}", ty, tcx.def_path_str(*bound)));
2251 for projection in &projections {
2252 let p = projection.skip_binder();
2253 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
2254 // insert the associated types where they correspond, but for now let's be "lazy" and
2255 // propose this instead of the following valid resugaring:
2256 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
2257 where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.item_def_id), p.ty));
2259 let where_clauses = if where_clauses.is_empty() {
2262 format!(" where {}", where_clauses.join(", "))
2264 (generics, where_clauses)
2267 /// Return placeholder code for the given function.
2268 fn fn_sig_suggestion(
2270 sig: &ty::FnSig<'_>,
2272 predicates: ty::GenericPredicates<'_>,
2273 assoc: &ty::AssocItem,
2280 Some(match ty.kind {
2281 ty::Param(_) if assoc.fn_has_self_parameter && i == 0 => "self".to_string(),
2282 ty::Ref(reg, ref_ty, mutability) if i == 0 => {
2283 let reg = match &format!("{}", reg)[..] {
2284 "'_" | "" => String::new(),
2285 reg => format!("{} ", reg),
2287 if assoc.fn_has_self_parameter {
2289 ty::Param(param) if param.name == kw::SelfUpper => {
2290 format!("&{}{}self", reg, mutability.prefix_str())
2293 _ => format!("self: {}", ty),
2296 format!("_: {:?}", ty)
2300 if assoc.fn_has_self_parameter && i == 0 {
2301 format!("self: {:?}", ty)
2303 format!("_: {:?}", ty)
2308 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2309 .filter_map(|arg| arg)
2310 .collect::<Vec<String>>()
2312 let output = sig.output();
2313 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2315 let unsafety = sig.unsafety.prefix_str();
2316 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
2318 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2319 // not be present in the `fn` definition, not will we account for renamed
2320 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2321 // fill in a significant portion of the missing code, and other subsequent
2322 // suggestions can help the user fix the code.
2324 "{}fn {}{}({}){}{} {{ todo!() }}",
2325 unsafety, ident, generics, args, output, where_clauses
2329 /// Return placeholder code for the given associated item.
2330 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2331 /// structured suggestion.
2332 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2334 ty::AssocKind::Fn => {
2335 // We skip the binder here because the binder would deanonymize all
2336 // late-bound regions, and we don't want method signatures to show up
2337 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2338 // regions just fine, showing `fn(&MyType)`.
2341 tcx.fn_sig(assoc.def_id).skip_binder(),
2343 tcx.predicates_of(assoc.def_id),
2347 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2348 // FIXME(type_alias_impl_trait): we should print bounds here too.
2349 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2350 ty::AssocKind::Const => {
2351 let ty = tcx.type_of(assoc.def_id);
2352 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2353 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2358 /// Checks whether a type can be represented in memory. In particular, it
2359 /// identifies types that contain themselves without indirection through a
2360 /// pointer, which would mean their size is unbounded.
2361 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2362 let rty = tcx.type_of(item_def_id);
2364 // Check that it is possible to represent this type. This call identifies
2365 // (1) types that contain themselves and (2) types that contain a different
2366 // recursive type. It is only necessary to throw an error on those that
2367 // contain themselves. For case 2, there must be an inner type that will be
2368 // caught by case 1.
2369 match rty.is_representable(tcx, sp) {
2370 Representability::SelfRecursive(spans) => {
2371 let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id);
2373 err.span_label(span, "recursive without indirection");
2378 Representability::Representable | Representability::ContainsRecursive => (),
2383 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2384 let t = tcx.type_of(def_id);
2385 if let ty::Adt(def, substs) = t.kind {
2386 if def.is_struct() {
2387 let fields = &def.non_enum_variant().fields;
2388 if fields.is_empty() {
2389 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2392 let e = fields[0].ty(tcx, substs);
2393 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2394 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2395 .span_label(sp, "SIMD elements must have the same type")
2400 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2401 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2407 "SIMD vector element type should be machine type"
2417 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2418 let repr = tcx.adt_def(def_id).repr;
2420 for attr in tcx.get_attrs(def_id).iter() {
2421 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2422 if let attr::ReprPacked(pack) = r {
2423 if let Some(repr_pack) = repr.pack {
2424 if pack as u64 != repr_pack.bytes() {
2429 "type has conflicting packed representation hints"
2437 if repr.align.is_some() {
2442 "type has conflicting packed and align representation hints"
2446 if let Some(def_spans) = check_packed_inner(tcx, def_id, &mut vec![]) {
2447 let mut err = struct_span_err!(
2451 "packed type cannot transitively contain a `#[repr(align)]` type"
2454 let hir = tcx.hir();
2455 if let Some(hir_id) = hir.as_local_hir_id(def_spans[0].0) {
2456 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2458 tcx.def_span(def_spans[0].0),
2459 &format!("`{}` has a `#[repr(align)]` attribute", ident),
2464 if def_spans.len() > 2 {
2465 let mut first = true;
2466 for (adt_def, span) in def_spans.iter().skip(1).rev() {
2467 if let Some(hir_id) = hir.as_local_hir_id(*adt_def) {
2468 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2473 "`{}` contains a field of type `{}`",
2474 tcx.type_of(def_id),
2478 format!("...which contains a field of type `{}`", ident)
2493 fn check_packed_inner(
2496 stack: &mut Vec<DefId>,
2497 ) -> Option<Vec<(DefId, Span)>> {
2498 if let ty::Adt(def, substs) = tcx.type_of(def_id).kind {
2499 if def.is_struct() || def.is_union() {
2500 if def.repr.align.is_some() {
2501 return Some(vec![(def.did, DUMMY_SP)]);
2505 for field in &def.non_enum_variant().fields {
2506 if let ty::Adt(def, _) = field.ty(tcx, substs).kind {
2507 if !stack.contains(&def.did) {
2508 if let Some(mut defs) = check_packed_inner(tcx, def.did, stack) {
2509 defs.push((def.did, field.ident.span));
2522 /// Emit an error when encountering more or less than one variant in a transparent enum.
2523 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2524 let variant_spans: Vec<_> = adt
2527 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2529 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2530 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2531 err.span_label(sp, &msg);
2532 if let [start @ .., end] = &*variant_spans {
2533 for variant_span in start {
2534 err.span_label(*variant_span, "");
2536 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2541 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2543 fn bad_non_zero_sized_fields<'tcx>(
2545 adt: &'tcx ty::AdtDef,
2547 field_spans: impl Iterator<Item = Span>,
2550 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2551 let mut err = struct_span_err!(
2555 "{}transparent {} {}",
2556 if adt.is_enum() { "the variant of a " } else { "" },
2560 err.span_label(sp, &msg);
2561 for sp in field_spans {
2562 err.span_label(sp, "this field is non-zero-sized");
2567 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2568 let adt = tcx.adt_def(def_id);
2569 if !adt.repr.transparent() {
2572 let sp = tcx.sess.source_map().guess_head_span(sp);
2574 if adt.is_union() && !tcx.features().transparent_unions {
2576 &tcx.sess.parse_sess,
2577 sym::transparent_unions,
2579 "transparent unions are unstable",
2584 if adt.variants.len() != 1 {
2585 bad_variant_count(tcx, adt, sp, def_id);
2586 if adt.variants.is_empty() {
2587 // Don't bother checking the fields. No variants (and thus no fields) exist.
2592 // For each field, figure out if it's known to be a ZST and align(1)
2593 let field_infos = adt.all_fields().map(|field| {
2594 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2595 let param_env = tcx.param_env(field.did);
2596 let layout = tcx.layout_of(param_env.and(ty));
2597 // We are currently checking the type this field came from, so it must be local
2598 let span = tcx.hir().span_if_local(field.did).unwrap();
2599 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2600 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2604 let non_zst_fields =
2605 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2606 let non_zst_count = non_zst_fields.clone().count();
2607 if non_zst_count != 1 {
2608 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2610 for (span, zst, align1) in field_infos {
2616 "zero-sized field in transparent {} has alignment larger than 1",
2619 .span_label(span, "has alignment larger than 1")
2625 #[allow(trivial_numeric_casts)]
2626 pub fn check_enum<'tcx>(
2629 vs: &'tcx [hir::Variant<'tcx>],
2632 let def_id = tcx.hir().local_def_id(id);
2633 let def = tcx.adt_def(def_id);
2634 def.destructor(tcx); // force the destructor to be evaluated
2637 let attributes = tcx.get_attrs(def_id);
2638 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2643 "unsupported representation for zero-variant enum"
2645 .span_label(sp, "zero-variant enum")
2650 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2651 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2652 if !tcx.features().repr128 {
2654 &tcx.sess.parse_sess,
2657 "repr with 128-bit type is unstable",
2664 if let Some(ref e) = v.disr_expr {
2665 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2669 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2670 let is_unit = |var: &hir::Variant<'_>| match var.data {
2671 hir::VariantData::Unit(..) => true,
2675 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2676 let has_non_units = vs.iter().any(|var| !is_unit(var));
2677 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2678 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2680 if disr_non_unit || (disr_units && has_non_units) {
2682 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2687 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2688 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2689 // Check for duplicate discriminant values
2690 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2691 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2692 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2693 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2694 let i_span = match variant_i.disr_expr {
2695 Some(ref expr) => tcx.hir().span(expr.hir_id),
2696 None => tcx.hir().span(variant_i_hir_id),
2698 let span = match v.disr_expr {
2699 Some(ref expr) => tcx.hir().span(expr.hir_id),
2706 "discriminant value `{}` already exists",
2709 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2710 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2713 disr_vals.push(discr);
2716 check_representable(tcx, sp, def_id);
2717 check_transparent(tcx, sp, def_id);
2720 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
2725 "expected unit struct, unit variant or constant, found {}{}",
2727 tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`", s)),
2732 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2733 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2737 fn item_def_id(&self) -> Option<DefId> {
2741 fn default_constness_for_trait_bounds(&self) -> hir::Constness {
2742 // FIXME: refactor this into a method
2743 let node = self.tcx.hir().get(self.body_id);
2744 if let Some(fn_like) = FnLikeNode::from_node(node) {
2747 hir::Constness::NotConst
2751 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2753 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2754 let item_id = tcx.hir().ty_param_owner(hir_id);
2755 let item_def_id = tcx.hir().local_def_id(item_id);
2756 let generics = tcx.generics_of(item_def_id);
2757 let index = generics.param_def_id_to_index[&def_id];
2758 ty::GenericPredicates {
2760 predicates: tcx.arena.alloc_from_iter(self.param_env.caller_bounds.iter().filter_map(
2761 |&predicate| match predicate {
2762 ty::Predicate::Trait(ref data, _)
2763 if data.skip_binder().self_ty().is_param(index) =>
2765 // HACK(eddyb) should get the original `Span`.
2766 let span = tcx.def_span(def_id);
2767 Some((predicate, span))
2775 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2777 Some(def) => infer::EarlyBoundRegion(span, def.name),
2778 None => infer::MiscVariable(span),
2780 Some(self.next_region_var(v))
2783 fn allow_ty_infer(&self) -> bool {
2787 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2788 if let Some(param) = param {
2789 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2794 self.next_ty_var(TypeVariableOrigin {
2795 kind: TypeVariableOriginKind::TypeInference,
2804 param: Option<&ty::GenericParamDef>,
2806 ) -> &'tcx Const<'tcx> {
2807 if let Some(param) = param {
2808 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2813 self.next_const_var(
2815 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2820 fn projected_ty_from_poly_trait_ref(
2824 item_segment: &hir::PathSegment<'_>,
2825 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2827 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2829 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2833 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
2842 self.tcx().mk_projection(item_def_id, item_substs)
2845 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2846 if ty.has_escaping_bound_vars() {
2847 ty // FIXME: normalization and escaping regions
2849 self.normalize_associated_types_in(span, &ty)
2853 fn set_tainted_by_errors(&self) {
2854 self.infcx.set_tainted_by_errors()
2857 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2858 self.write_ty(hir_id, ty)
2862 /// Controls whether the arguments are tupled. This is used for the call
2865 /// Tupling means that all call-side arguments are packed into a tuple and
2866 /// passed as a single parameter. For example, if tupling is enabled, this
2869 /// fn f(x: (isize, isize))
2871 /// Can be called as:
2878 #[derive(Clone, Eq, PartialEq)]
2879 enum TupleArgumentsFlag {
2884 /// Controls how we perform fallback for unconstrained
2887 /// Do not fallback type variables to opaque types.
2889 /// Perform all possible kinds of fallback, including
2890 /// turning type variables to opaque types.
2894 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2896 inh: &'a Inherited<'a, 'tcx>,
2897 param_env: ty::ParamEnv<'tcx>,
2898 body_id: hir::HirId,
2899 ) -> FnCtxt<'a, 'tcx> {
2903 err_count_on_creation: inh.tcx.sess.err_count(),
2905 ret_coercion_span: RefCell::new(None),
2906 resume_yield_tys: None,
2907 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
2908 diverges: Cell::new(Diverges::Maybe),
2909 has_errors: Cell::new(false),
2910 enclosing_breakables: RefCell::new(EnclosingBreakables {
2912 by_id: Default::default(),
2918 pub fn sess(&self) -> &Session {
2922 pub fn errors_reported_since_creation(&self) -> bool {
2923 self.tcx.sess.err_count() > self.err_count_on_creation
2926 /// Produces warning on the given node, if the current point in the
2927 /// function is unreachable, and there hasn't been another warning.
2928 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2929 // FIXME: Combine these two 'if' expressions into one once
2930 // let chains are implemented
2931 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2932 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2933 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2934 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2935 if !span.is_desugaring(DesugaringKind::CondTemporary)
2936 && !span.is_desugaring(DesugaringKind::Async)
2937 && !orig_span.is_desugaring(DesugaringKind::Await)
2939 self.diverges.set(Diverges::WarnedAlways);
2941 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2943 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, |lint| {
2944 let msg = format!("unreachable {}", kind);
2946 .span_label(span, &msg)
2950 .unwrap_or("any code following this expression is unreachable"),
2958 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
2959 ObligationCause::new(span, self.body_id, code)
2962 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2963 self.cause(span, ObligationCauseCode::MiscObligation)
2966 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2967 /// version (resolve_vars_if_possible), this version will
2968 /// also select obligations if it seems useful, in an effort
2969 /// to get more type information.
2970 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2971 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2973 // No Infer()? Nothing needs doing.
2974 if !ty.has_infer_types_or_consts() {
2975 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2979 // If `ty` is a type variable, see whether we already know what it is.
2980 ty = self.resolve_vars_if_possible(&ty);
2981 if !ty.has_infer_types_or_consts() {
2982 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2986 // If not, try resolving pending obligations as much as
2987 // possible. This can help substantially when there are
2988 // indirect dependencies that don't seem worth tracking
2990 self.select_obligations_where_possible(false, |_| {});
2991 ty = self.resolve_vars_if_possible(&ty);
2993 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2997 fn record_deferred_call_resolution(
2999 closure_def_id: DefId,
3000 r: DeferredCallResolution<'tcx>,
3002 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3003 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
3006 fn remove_deferred_call_resolutions(
3008 closure_def_id: DefId,
3009 ) -> Vec<DeferredCallResolution<'tcx>> {
3010 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3011 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
3014 pub fn tag(&self) -> String {
3015 format!("{:p}", self)
3018 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
3019 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
3020 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
3025 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
3027 "write_ty({:?}, {:?}) in fcx {}",
3029 self.resolve_vars_if_possible(&ty),
3032 self.tables.borrow_mut().node_types_mut().insert(id, ty);
3034 if ty.references_error() {
3035 self.has_errors.set(true);
3036 self.set_tainted_by_errors();
3040 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
3041 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
3044 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
3045 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
3048 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
3049 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
3050 self.write_resolution(hir_id, Ok((DefKind::AssocFn, method.def_id)));
3051 self.write_substs(hir_id, method.substs);
3053 // When the method is confirmed, the `method.substs` includes
3054 // parameters from not just the method, but also the impl of
3055 // the method -- in particular, the `Self` type will be fully
3056 // resolved. However, those are not something that the "user
3057 // specified" -- i.e., those types come from the inferred type
3058 // of the receiver, not something the user wrote. So when we
3059 // create the user-substs, we want to replace those earlier
3060 // types with just the types that the user actually wrote --
3061 // that is, those that appear on the *method itself*.
3063 // As an example, if the user wrote something like
3064 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
3065 // type of `foo` (possibly adjusted), but we don't want to
3066 // include that. We want just the `[_, u32]` part.
3067 if !method.substs.is_noop() {
3068 let method_generics = self.tcx.generics_of(method.def_id);
3069 if !method_generics.params.is_empty() {
3070 let user_type_annotation = self.infcx.probe(|_| {
3071 let user_substs = UserSubsts {
3072 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
3073 let i = param.index as usize;
3074 if i < method_generics.parent_count {
3075 self.infcx.var_for_def(DUMMY_SP, param)
3080 user_self_ty: None, // not relevant here
3083 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3089 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
3090 self.write_user_type_annotation(hir_id, user_type_annotation);
3095 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
3096 if !substs.is_noop() {
3097 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
3099 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
3103 /// Given the substs that we just converted from the HIR, try to
3104 /// canonicalize them and store them as user-given substitutions
3105 /// (i.e., substitutions that must be respected by the NLL check).
3107 /// This should be invoked **before any unifications have
3108 /// occurred**, so that annotations like `Vec<_>` are preserved
3110 pub fn write_user_type_annotation_from_substs(
3114 substs: SubstsRef<'tcx>,
3115 user_self_ty: Option<UserSelfTy<'tcx>>,
3118 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
3119 user_self_ty={:?} in fcx {}",
3127 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
3128 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3130 UserSubsts { substs, user_self_ty },
3132 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
3133 self.write_user_type_annotation(hir_id, canonicalized);
3137 pub fn write_user_type_annotation(
3140 canonical_user_type_annotation: CanonicalUserType<'tcx>,
3143 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
3145 canonical_user_type_annotation,
3149 if !canonical_user_type_annotation.is_identity() {
3152 .user_provided_types_mut()
3153 .insert(hir_id, canonical_user_type_annotation);
3155 debug!("write_user_type_annotation: skipping identity substs");
3159 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
3160 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
3166 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
3167 Entry::Vacant(entry) => {
3170 Entry::Occupied(mut entry) => {
3171 debug!(" - composing on top of {:?}", entry.get());
3172 match (&entry.get()[..], &adj[..]) {
3173 // Applying any adjustment on top of a NeverToAny
3174 // is a valid NeverToAny adjustment, because it can't
3176 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3178 Adjustment { kind: Adjust::Deref(_), .. },
3179 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3181 Adjustment { kind: Adjust::Deref(_), .. },
3182 .. // Any following adjustments are allowed.
3184 // A reborrow has no effect before a dereference.
3186 // FIXME: currently we never try to compose autoderefs
3187 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3189 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3190 expr, entry.get(), adj)
3192 *entry.get_mut() = adj;
3197 /// Basically whenever we are converting from a type scheme into
3198 /// the fn body space, we always want to normalize associated
3199 /// types as well. This function combines the two.
3200 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3202 T: TypeFoldable<'tcx>,
3204 let value = value.subst(self.tcx, substs);
3205 let result = self.normalize_associated_types_in(span, &value);
3206 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3210 /// As `instantiate_type_scheme`, but for the bounds found in a
3211 /// generic type scheme.
3212 fn instantiate_bounds(
3216 substs: SubstsRef<'tcx>,
3217 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3218 let bounds = self.tcx.predicates_of(def_id);
3219 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3220 let result = bounds.instantiate(self.tcx, substs);
3221 let result = self.normalize_associated_types_in(span, &result);
3223 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3224 bounds, substs, result, spans,
3229 /// Replaces the opaque types from the given value with type variables,
3230 /// and records the `OpaqueTypeMap` for later use during writeback. See
3231 /// `InferCtxt::instantiate_opaque_types` for more details.
3232 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3234 parent_id: hir::HirId,
3238 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3240 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3241 parent_def_id, value
3244 let (value, opaque_type_map) =
3245 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3253 let mut opaque_types = self.opaque_types.borrow_mut();
3254 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3255 for (ty, decl) in opaque_type_map {
3256 let _ = opaque_types.insert(ty, decl);
3257 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3263 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3265 T: TypeFoldable<'tcx>,
3267 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3270 fn normalize_associated_types_in_as_infer_ok<T>(
3274 ) -> InferOk<'tcx, T>
3276 T: TypeFoldable<'tcx>,
3278 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3281 pub fn require_type_meets(
3285 code: traits::ObligationCauseCode<'tcx>,
3288 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3291 pub fn require_type_is_sized(
3295 code: traits::ObligationCauseCode<'tcx>,
3297 if !ty.references_error() {
3298 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3299 self.require_type_meets(ty, span, code, lang_item);
3303 pub fn require_type_is_sized_deferred(
3307 code: traits::ObligationCauseCode<'tcx>,
3309 if !ty.references_error() {
3310 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3314 pub fn register_bound(
3318 cause: traits::ObligationCause<'tcx>,
3320 if !ty.references_error() {
3321 self.fulfillment_cx.borrow_mut().register_bound(
3331 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3332 let t = AstConv::ast_ty_to_ty(self, ast_t);
3333 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3337 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3338 let ty = self.to_ty(ast_ty);
3339 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3341 if Self::can_contain_user_lifetime_bounds(ty) {
3342 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3343 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3344 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3350 pub fn to_const(&self, ast_c: &hir::AnonConst) -> &'tcx ty::Const<'tcx> {
3351 let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id).expect_local();
3352 let c = ty::Const::from_anon_const(self.tcx, const_def_id);
3354 // HACK(eddyb) emulate what a `WellFormedConst` obligation would do.
3355 // This code should be replaced with the proper WF handling ASAP.
3356 if let ty::ConstKind::Unevaluated(def_id, substs, promoted) = c.val {
3357 assert!(promoted.is_none());
3359 // HACK(eddyb) let's hope these are always empty.
3360 // let obligations = self.nominal_obligations(def_id, substs);
3361 // self.out.extend(obligations);
3363 let cause = traits::ObligationCause::new(
3364 self.tcx.def_span(const_def_id.to_def_id()),
3366 traits::MiscObligation,
3368 self.register_predicate(traits::Obligation::new(
3371 ty::Predicate::ConstEvaluatable(def_id, substs),
3378 // If the type given by the user has free regions, save it for later, since
3379 // NLL would like to enforce those. Also pass in types that involve
3380 // projections, since those can resolve to `'static` bounds (modulo #54940,
3381 // which hopefully will be fixed by the time you see this comment, dear
3382 // reader, although I have my doubts). Also pass in types with inference
3383 // types, because they may be repeated. Other sorts of things are already
3384 // sufficiently enforced with erased regions. =)
3385 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3387 T: TypeFoldable<'tcx>,
3389 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3392 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3393 match self.tables.borrow().node_types().get(id) {
3395 None if self.is_tainted_by_errors() => self.tcx.types.err,
3398 "no type for node {}: {} in fcx {}",
3400 self.tcx.hir().node_to_string(id),
3407 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3408 /// outlive the region `r`.
3409 pub fn register_wf_obligation(
3413 code: traits::ObligationCauseCode<'tcx>,
3415 // WF obligations never themselves fail, so no real need to give a detailed cause:
3416 let cause = traits::ObligationCause::new(span, self.body_id, code);
3417 self.register_predicate(traits::Obligation::new(
3420 ty::Predicate::WellFormed(ty),
3424 /// Registers obligations that all types appearing in `substs` are well-formed.
3425 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3426 for ty in substs.types() {
3427 if !ty.references_error() {
3428 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3433 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3434 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3435 /// trait/region obligations.
3437 /// For example, if there is a function:
3440 /// fn foo<'a,T:'a>(...)
3443 /// and a reference:
3449 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3450 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3451 pub fn add_obligations_for_parameters(
3453 cause: traits::ObligationCause<'tcx>,
3454 predicates: &ty::InstantiatedPredicates<'tcx>,
3456 assert!(!predicates.has_escaping_bound_vars());
3458 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3460 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3461 self.register_predicate(obligation);
3465 // FIXME(arielb1): use this instead of field.ty everywhere
3466 // Only for fields! Returns <none> for methods>
3467 // Indifferent to privacy flags
3471 field: &'tcx ty::FieldDef,
3472 substs: SubstsRef<'tcx>,
3474 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3477 fn check_casts(&self) {
3478 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3479 for cast in deferred_cast_checks.drain(..) {
3484 fn resolve_generator_interiors(&self, def_id: DefId) {
3485 let mut generators = self.deferred_generator_interiors.borrow_mut();
3486 for (body_id, interior, kind) in generators.drain(..) {
3487 self.select_obligations_where_possible(false, |_| {});
3488 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3492 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3494 // - Unconstrained ints are replaced with `i32`.
3496 // - Unconstrained floats are replaced with with `f64`.
3498 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3499 // is enabled. Otherwise, they are replaced with `()`.
3501 // Fallback becomes very dubious if we have encountered type-checking errors.
3502 // In that case, fallback to Error.
3503 // The return value indicates whether fallback has occurred.
3504 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3505 use rustc_middle::ty::error::UnconstrainedNumeric::Neither;
3506 use rustc_middle::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3508 assert!(ty.is_ty_infer());
3509 let fallback = match self.type_is_unconstrained_numeric(ty) {
3510 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3511 UnconstrainedInt => self.tcx.types.i32,
3512 UnconstrainedFloat => self.tcx.types.f64,
3513 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3515 // This type variable was created from the instantiation of an opaque
3516 // type. The fact that we're attempting to perform fallback for it
3517 // means that the function neither constrained it to a concrete
3518 // type, nor to the opaque type itself.
3520 // For example, in this code:
3523 // type MyType = impl Copy;
3524 // fn defining_use() -> MyType { true }
3525 // fn other_use() -> MyType { defining_use() }
3528 // `defining_use` will constrain the instantiated inference
3529 // variable to `bool`, while `other_use` will constrain
3530 // the instantiated inference variable to `MyType`.
3532 // When we process opaque types during writeback, we
3533 // will handle cases like `other_use`, and not count
3534 // them as defining usages
3536 // However, we also need to handle cases like this:
3539 // pub type Foo = impl Copy;
3540 // fn produce() -> Option<Foo> {
3545 // In the above snippet, the inference variable created by
3546 // instantiating `Option<Foo>` will be completely unconstrained.
3547 // We treat this as a non-defining use by making the inference
3548 // variable fall back to the opaque type itself.
3549 if let FallbackMode::All = mode {
3550 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3552 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3564 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3565 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3569 fn select_all_obligations_or_error(&self) {
3570 debug!("select_all_obligations_or_error");
3571 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3572 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3576 /// Select as many obligations as we can at present.
3577 fn select_obligations_where_possible(
3579 fallback_has_occurred: bool,
3580 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3582 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3583 if let Err(mut errors) = result {
3584 mutate_fullfillment_errors(&mut errors);
3585 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3589 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3590 /// returns a type of `&T`, but the actual type we assign to the
3591 /// *expression* is `T`. So this function just peels off the return
3592 /// type by one layer to yield `T`.
3593 fn make_overloaded_place_return_type(
3595 method: MethodCallee<'tcx>,
3596 ) -> ty::TypeAndMut<'tcx> {
3597 // extract method return type, which will be &T;
3598 let ret_ty = method.sig.output();
3600 // method returns &T, but the type as visible to user is T, so deref
3601 ret_ty.builtin_deref(true).unwrap()
3606 expr: &hir::Expr<'_>,
3607 base_expr: &'tcx hir::Expr<'tcx>,
3611 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3612 // FIXME(#18741) -- this is almost but not quite the same as the
3613 // autoderef that normal method probing does. They could likely be
3616 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3617 let mut result = None;
3618 while result.is_none() && autoderef.next().is_some() {
3619 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3621 autoderef.finalize(self);
3625 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3626 /// (and otherwise adjust) `base_expr`, looking for a type which either
3627 /// supports builtin indexing or overloaded indexing.
3628 /// This loop implements one step in that search; the autoderef loop
3629 /// is implemented by `lookup_indexing`.
3632 expr: &hir::Expr<'_>,
3633 base_expr: &hir::Expr<'_>,
3634 autoderef: &Autoderef<'a, 'tcx>,
3637 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3638 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3640 "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3642 expr, base_expr, adjusted_ty, index_ty
3645 for &unsize in &[false, true] {
3646 let mut self_ty = adjusted_ty;
3648 // We only unsize arrays here.
3649 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3650 self_ty = self.tcx.mk_slice(element_ty);
3656 // If some lookup succeeds, write callee into table and extract index/element
3657 // type from the method signature.
3658 // If some lookup succeeded, install method in table
3659 let input_ty = self.next_ty_var(TypeVariableOrigin {
3660 kind: TypeVariableOriginKind::AutoDeref,
3661 span: base_expr.span,
3663 let method = self.try_overloaded_place_op(
3671 let result = method.map(|ok| {
3672 debug!("try_index_step: success, using overloaded indexing");
3673 let method = self.register_infer_ok_obligations(ok);
3675 let mut adjustments = autoderef.adjust_steps(self, needs);
3676 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3677 let mutbl = match r_mutbl {
3678 hir::Mutability::Not => AutoBorrowMutability::Not,
3679 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3680 // Indexing can be desugared to a method call,
3681 // so maybe we could use two-phase here.
3682 // See the documentation of AllowTwoPhase for why that's
3683 // not the case today.
3684 allow_two_phase_borrow: AllowTwoPhase::No,
3687 adjustments.push(Adjustment {
3688 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3691 .mk_ref(region, ty::TypeAndMut { mutbl: r_mutbl, ty: adjusted_ty }),
3695 adjustments.push(Adjustment {
3696 kind: Adjust::Pointer(PointerCast::Unsize),
3697 target: method.sig.inputs()[0],
3700 self.apply_adjustments(base_expr, adjustments);
3702 self.write_method_call(expr.hir_id, method);
3703 (input_ty, self.make_overloaded_place_return_type(method).ty)
3705 if result.is_some() {
3713 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3714 let (tr, name) = match (op, is_mut) {
3715 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3716 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3717 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3718 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3720 (tr, ast::Ident::with_dummy_span(name))
3723 fn try_overloaded_place_op(
3727 arg_tys: &[Ty<'tcx>],
3730 ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
3731 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})", span, base_ty, needs, op);
3733 // Try Mut first, if needed.
3734 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3735 let method = match (needs, mut_tr) {
3736 (Needs::MutPlace, Some(trait_did)) => {
3737 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3742 // Otherwise, fall back to the immutable version.
3743 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3744 match (method, imm_tr) {
3745 (None, Some(trait_did)) => {
3746 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3748 (method, _) => method,
3752 fn check_method_argument_types(
3755 expr: &'tcx hir::Expr<'tcx>,
3756 method: Result<MethodCallee<'tcx>, ()>,
3757 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3758 tuple_arguments: TupleArgumentsFlag,
3759 expected: Expectation<'tcx>,
3761 let has_error = match method {
3762 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3766 let err_inputs = self.err_args(args_no_rcvr.len());
3768 let err_inputs = match tuple_arguments {
3769 DontTupleArguments => err_inputs,
3770 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3773 self.check_argument_types(
3783 return self.tcx.types.err;
3786 let method = method.unwrap();
3787 // HACK(eddyb) ignore self in the definition (see above).
3788 let expected_arg_tys = self.expected_inputs_for_expected_output(
3791 method.sig.output(),
3792 &method.sig.inputs()[1..],
3794 self.check_argument_types(
3797 &method.sig.inputs()[1..],
3798 &expected_arg_tys[..],
3800 method.sig.c_variadic,
3802 self.tcx.hir().span_if_local(method.def_id),
3807 fn self_type_matches_expected_vid(
3809 trait_ref: ty::PolyTraitRef<'tcx>,
3810 expected_vid: ty::TyVid,
3812 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3814 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3815 trait_ref, self_ty, expected_vid
3817 match self_ty.kind {
3818 ty::Infer(ty::TyVar(found_vid)) => {
3819 // FIXME: consider using `sub_root_var` here so we
3820 // can see through subtyping.
3821 let found_vid = self.root_var(found_vid);
3822 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3823 expected_vid == found_vid
3829 fn obligations_for_self_ty<'b>(
3832 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3835 // FIXME: consider using `sub_root_var` here so we
3836 // can see through subtyping.
3837 let ty_var_root = self.root_var(self_ty);
3839 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3842 self.fulfillment_cx.borrow().pending_obligations()
3847 .pending_obligations()
3849 .filter_map(move |obligation| match obligation.predicate {
3850 ty::Predicate::Projection(ref data) => {
3851 Some((data.to_poly_trait_ref(self.tcx), obligation))
3853 ty::Predicate::Trait(ref data, _) => Some((data.to_poly_trait_ref(), obligation)),
3854 ty::Predicate::Subtype(..) => None,
3855 ty::Predicate::RegionOutlives(..) => None,
3856 ty::Predicate::TypeOutlives(..) => None,
3857 ty::Predicate::WellFormed(..) => None,
3858 ty::Predicate::ObjectSafe(..) => None,
3859 ty::Predicate::ConstEvaluatable(..) => None,
3860 // N.B., this predicate is created by breaking down a
3861 // `ClosureType: FnFoo()` predicate, where
3862 // `ClosureType` represents some `Closure`. It can't
3863 // possibly be referring to the current closure,
3864 // because we haven't produced the `Closure` for
3865 // this closure yet; this is exactly why the other
3866 // code is looking for a self type of a unresolved
3867 // inference variable.
3868 ty::Predicate::ClosureKind(..) => None,
3870 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3873 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3874 self.obligations_for_self_ty(self_ty)
3875 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3878 /// Generic function that factors out common logic from function calls,
3879 /// method calls and overloaded operators.
3880 fn check_argument_types(
3883 expr: &'tcx hir::Expr<'tcx>,
3884 fn_inputs: &[Ty<'tcx>],
3885 expected_arg_tys: &[Ty<'tcx>],
3886 args: &'tcx [hir::Expr<'tcx>],
3888 tuple_arguments: TupleArgumentsFlag,
3889 def_span: Option<Span>,
3892 // Grab the argument types, supplying fresh type variables
3893 // if the wrong number of arguments were supplied
3894 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3896 // All the input types from the fn signature must outlive the call
3897 // so as to validate implied bounds.
3898 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3899 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3902 let expected_arg_count = fn_inputs.len();
3904 let param_count_error = |expected_count: usize,
3909 let (span, start_span, args) = match &expr.kind {
3910 hir::ExprKind::Call(hir::Expr { span, .. }, args) => (*span, *span, &args[..]),
3911 hir::ExprKind::MethodCall(path_segment, span, args) => (
3913 // `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
3916 .and_then(|args| args.args.iter().last())
3917 // Account for `foo.bar::<T>()`.
3919 // Skip the closing `>`.
3922 .next_point(tcx.sess.source_map().next_point(arg.span()))
3925 &args[1..], // Skip the receiver.
3927 k => span_bug!(sp, "checking argument types on a non-call: `{:?}`", k),
3929 let arg_spans = if args.is_empty() {
3931 // ^^^-- supplied 0 arguments
3933 // expected 2 arguments
3934 vec![tcx.sess.source_map().next_point(start_span).with_hi(sp.hi())]
3937 // ^^^ - - - supplied 3 arguments
3939 // expected 2 arguments
3940 args.iter().map(|arg| arg.span).collect::<Vec<Span>>()
3943 let mut err = tcx.sess.struct_span_err_with_code(
3946 "this function takes {}{} but {} {} supplied",
3947 if c_variadic { "at least " } else { "" },
3948 potentially_plural_count(expected_count, "argument"),
3949 potentially_plural_count(arg_count, "argument"),
3950 if arg_count == 1 { "was" } else { "were" }
3952 DiagnosticId::Error(error_code.to_owned()),
3954 let label = format!("supplied {}", potentially_plural_count(arg_count, "argument"));
3955 for (i, span) in arg_spans.into_iter().enumerate() {
3958 if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
3962 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().guess_head_span(sp)) {
3963 err.span_label(def_s, "defined here");
3966 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3967 // remove closing `)` from the span
3968 let sugg_span = sugg_span.shrink_to_lo();
3969 err.span_suggestion(
3971 "expected the unit value `()`; create it with empty parentheses",
3973 Applicability::MachineApplicable,
3980 if c_variadic { "at least " } else { "" },
3981 potentially_plural_count(expected_count, "argument")
3988 let mut expected_arg_tys = expected_arg_tys.to_vec();
3990 let formal_tys = if tuple_arguments == TupleArguments {
3991 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3992 match tuple_type.kind {
3993 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3994 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3995 expected_arg_tys = vec![];
3996 self.err_args(args.len())
3998 ty::Tuple(arg_types) => {
3999 expected_arg_tys = match expected_arg_tys.get(0) {
4000 Some(&ty) => match ty.kind {
4001 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
4006 arg_types.iter().map(|k| k.expect_ty()).collect()
4013 "cannot use call notation; the first type parameter \
4014 for the function trait is neither a tuple nor unit"
4017 expected_arg_tys = vec![];
4018 self.err_args(args.len())
4021 } else if expected_arg_count == supplied_arg_count {
4023 } else if c_variadic {
4024 if supplied_arg_count >= expected_arg_count {
4027 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
4028 expected_arg_tys = vec![];
4029 self.err_args(supplied_arg_count)
4032 // is the missing argument of type `()`?
4033 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
4034 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
4035 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
4036 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
4040 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
4042 expected_arg_tys = vec![];
4043 self.err_args(supplied_arg_count)
4047 "check_argument_types: formal_tys={:?}",
4048 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
4051 // If there is no expectation, expect formal_tys.
4052 let expected_arg_tys =
4053 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
4055 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
4057 // Check the arguments.
4058 // We do this in a pretty awful way: first we type-check any arguments
4059 // that are not closures, then we type-check the closures. This is so
4060 // that we have more information about the types of arguments when we
4061 // type-check the functions. This isn't really the right way to do this.
4062 for &check_closures in &[false, true] {
4063 debug!("check_closures={}", check_closures);
4065 // More awful hacks: before we check argument types, try to do
4066 // an "opportunistic" vtable resolution of any trait bounds on
4067 // the call. This helps coercions.
4069 self.select_obligations_where_possible(false, |errors| {
4070 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
4071 self.point_at_arg_instead_of_call_if_possible(
4073 &final_arg_types[..],
4080 // For C-variadic functions, we don't have a declared type for all of
4081 // the arguments hence we only do our usual type checking with
4082 // the arguments who's types we do know.
4083 let t = if c_variadic {
4085 } else if tuple_arguments == TupleArguments {
4090 for (i, arg) in args.iter().take(t).enumerate() {
4091 // Warn only for the first loop (the "no closures" one).
4092 // Closure arguments themselves can't be diverging, but
4093 // a previous argument can, e.g., `foo(panic!(), || {})`.
4094 if !check_closures {
4095 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
4098 let is_closure = match arg.kind {
4099 ExprKind::Closure(..) => true,
4103 if is_closure != check_closures {
4107 debug!("checking the argument");
4108 let formal_ty = formal_tys[i];
4110 // The special-cased logic below has three functions:
4111 // 1. Provide as good of an expected type as possible.
4112 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
4114 let checked_ty = self.check_expr_with_expectation(&arg, expected);
4116 // 2. Coerce to the most detailed type that could be coerced
4117 // to, which is `expected_ty` if `rvalue_hint` returns an
4118 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
4119 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
4120 // We're processing function arguments so we definitely want to use
4121 // two-phase borrows.
4122 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
4123 final_arg_types.push((i, checked_ty, coerce_ty));
4125 // 3. Relate the expected type and the formal one,
4126 // if the expected type was used for the coercion.
4127 self.demand_suptype(arg.span, formal_ty, coerce_ty);
4131 // We also need to make sure we at least write the ty of the other
4132 // arguments which we skipped above.
4134 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
4135 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
4136 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
4139 for arg in args.iter().skip(expected_arg_count) {
4140 let arg_ty = self.check_expr(&arg);
4142 // There are a few types which get autopromoted when passed via varargs
4143 // in C but we just error out instead and require explicit casts.
4144 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
4146 ty::Float(ast::FloatTy::F32) => {
4147 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
4149 ty::Int(ast::IntTy::I8 | ast::IntTy::I16) | ty::Bool => {
4150 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
4152 ty::Uint(ast::UintTy::U8 | ast::UintTy::U16) => {
4153 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
4156 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
4157 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
4158 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
4166 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
4167 vec![self.tcx.types.err; len]
4170 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
4171 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
4172 /// reference a type argument. The reason to walk also the checked type is that the coerced type
4173 /// can be not easily comparable with predicate type (because of coercion). If the types match
4174 /// for either checked or coerced type, and there's only *one* argument that does, we point at
4175 /// the corresponding argument's expression span instead of the `fn` call path span.
4176 fn point_at_arg_instead_of_call_if_possible(
4178 errors: &mut Vec<traits::FulfillmentError<'_>>,
4179 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
4181 args: &'tcx [hir::Expr<'tcx>],
4183 // We *do not* do this for desugared call spans to keep good diagnostics when involving
4184 // the `?` operator.
4185 if call_sp.desugaring_kind().is_some() {
4189 for error in errors {
4190 // Only if the cause is somewhere inside the expression we want try to point at arg.
4191 // Otherwise, it means that the cause is somewhere else and we should not change
4192 // anything because we can break the correct span.
4193 if !call_sp.contains(error.obligation.cause.span) {
4197 if let ty::Predicate::Trait(predicate, _) = error.obligation.predicate {
4198 // Collect the argument position for all arguments that could have caused this
4199 // `FulfillmentError`.
4200 let mut referenced_in = final_arg_types
4202 .map(|&(i, checked_ty, _)| (i, checked_ty))
4203 .chain(final_arg_types.iter().map(|&(i, _, coerced_ty)| (i, coerced_ty)))
4204 .flat_map(|(i, ty)| {
4205 let ty = self.resolve_vars_if_possible(&ty);
4206 // We walk the argument type because the argument's type could have
4207 // been `Option<T>`, but the `FulfillmentError` references `T`.
4208 if ty.walk().any(|arg| arg == predicate.skip_binder().self_ty().into()) {
4214 .collect::<Vec<_>>();
4216 // Both checked and coerced types could have matched, thus we need to remove
4218 referenced_in.sort();
4219 referenced_in.dedup();
4221 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
4222 // We make sure that only *one* argument matches the obligation failure
4223 // and we assign the obligation's span to its expression's.
4224 error.obligation.cause.span = args[ref_in].span;
4225 error.points_at_arg_span = true;
4231 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4232 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4233 /// were caused by them. If they were, we point at the corresponding type argument's span
4234 /// instead of the `fn` call path span.
4235 fn point_at_type_arg_instead_of_call_if_possible(
4237 errors: &mut Vec<traits::FulfillmentError<'_>>,
4238 call_expr: &'tcx hir::Expr<'tcx>,
4240 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4241 if let hir::ExprKind::Path(qpath) = &path.kind {
4242 if let hir::QPath::Resolved(_, path) = &qpath {
4243 for error in errors {
4244 if let ty::Predicate::Trait(predicate, _) = error.obligation.predicate {
4245 // If any of the type arguments in this path segment caused the
4246 // `FullfillmentError`, point at its span (#61860).
4250 .filter_map(|seg| seg.args.as_ref())
4251 .flat_map(|a| a.args.iter())
4253 if let hir::GenericArg::Type(hir_ty) = &arg {
4254 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4257 // Avoid ICE with associated types. As this is best
4258 // effort only, it's ok to ignore the case. It
4259 // would trigger in `is_send::<T::AssocType>();`
4260 // from `typeck-default-trait-impl-assoc-type.rs`.
4262 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4263 let ty = self.resolve_vars_if_possible(&ty);
4264 if ty == predicate.skip_binder().self_ty() {
4265 error.obligation.cause.span = hir_ty.span;
4277 // AST fragment checking
4278 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4282 ast::LitKind::Str(..) => tcx.mk_static_str(),
4283 ast::LitKind::ByteStr(ref v) => {
4284 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4286 ast::LitKind::Byte(_) => tcx.types.u8,
4287 ast::LitKind::Char(_) => tcx.types.char,
4288 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4289 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4290 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4291 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4292 ty::Int(_) | ty::Uint(_) => Some(ty),
4293 ty::Char => Some(tcx.types.u8),
4294 ty::RawPtr(..) => Some(tcx.types.usize),
4295 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4298 opt_ty.unwrap_or_else(|| self.next_int_var())
4300 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4301 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4302 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4303 ty::Float(_) => Some(ty),
4306 opt_ty.unwrap_or_else(|| self.next_float_var())
4308 ast::LitKind::Bool(_) => tcx.types.bool,
4309 ast::LitKind::Err(_) => tcx.types.err,
4313 /// Unifies the output type with the expected type early, for more coercions
4314 /// and forward type information on the input expressions.
4315 fn expected_inputs_for_expected_output(
4318 expected_ret: Expectation<'tcx>,
4319 formal_ret: Ty<'tcx>,
4320 formal_args: &[Ty<'tcx>],
4321 ) -> Vec<Ty<'tcx>> {
4322 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4323 let ret_ty = match expected_ret.only_has_type(self) {
4325 None => return Vec::new(),
4327 let expect_args = self
4328 .fudge_inference_if_ok(|| {
4329 // Attempt to apply a subtyping relationship between the formal
4330 // return type (likely containing type variables if the function
4331 // is polymorphic) and the expected return type.
4332 // No argument expectations are produced if unification fails.
4333 let origin = self.misc(call_span);
4334 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4336 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4337 // to identity so the resulting type is not constrained.
4340 // Process any obligations locally as much as
4341 // we can. We don't care if some things turn
4342 // out unconstrained or ambiguous, as we're
4343 // just trying to get hints here.
4344 self.save_and_restore_in_snapshot_flag(|_| {
4345 let mut fulfill = TraitEngine::new(self.tcx);
4346 for obligation in ok.obligations {
4347 fulfill.register_predicate_obligation(self, obligation);
4349 fulfill.select_where_possible(self)
4353 Err(_) => return Err(()),
4356 // Record all the argument types, with the substitutions
4357 // produced from the above subtyping unification.
4358 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4360 .unwrap_or_default();
4362 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4363 formal_args, formal_ret, expect_args, expected_ret
4368 pub fn check_struct_path(
4372 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4373 let path_span = match *qpath {
4374 QPath::Resolved(_, ref path) => path.span,
4375 QPath::TypeRelative(ref qself, _) => qself.span,
4377 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4378 let variant = match def {
4380 self.set_tainted_by_errors();
4383 Res::Def(DefKind::Variant, _) => match ty.kind {
4384 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4385 _ => bug!("unexpected type: {:?}", ty),
4387 Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
4388 | Res::SelfTy(..) => match ty.kind {
4389 ty::Adt(adt, substs) if !adt.is_enum() => {
4390 Some((adt.non_enum_variant(), adt.did, substs))
4394 _ => bug!("unexpected definition: {:?}", def),
4397 if let Some((variant, did, substs)) = variant {
4398 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4399 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4401 // Check bounds on type arguments used in the path.
4402 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4404 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4405 self.add_obligations_for_parameters(cause, &bounds);
4413 "expected struct, variant or union type, found {}",
4414 ty.sort_string(self.tcx)
4416 .span_label(path_span, "not a struct")
4422 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4423 // The newly resolved definition is written into `type_dependent_defs`.
4424 fn finish_resolving_struct_path(
4429 ) -> (Res, Ty<'tcx>) {
4431 QPath::Resolved(ref maybe_qself, ref path) => {
4432 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4433 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4436 QPath::TypeRelative(ref qself, ref segment) => {
4437 let ty = self.to_ty(qself);
4439 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4445 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4446 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4447 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4449 // Write back the new resolution.
4450 self.write_resolution(hir_id, result);
4452 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4457 /// Resolves an associated value path into a base type and associated constant, or method
4458 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4459 pub fn resolve_ty_and_res_ufcs<'b>(
4461 qpath: &'b QPath<'b>,
4464 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4465 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4466 let (ty, qself, item_segment) = match *qpath {
4467 QPath::Resolved(ref opt_qself, ref path) => {
4470 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4474 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4476 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4477 // Return directly on cache hit. This is useful to avoid doubly reporting
4478 // errors with default match binding modes. See #44614.
4480 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4481 return (def, Some(ty), slice::from_ref(&**item_segment));
4483 let item_name = item_segment.ident;
4484 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4485 let result = match error {
4486 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4487 _ => Err(ErrorReported),
4489 if item_name.name != kw::Invalid {
4490 self.report_method_error(
4494 SelfSource::QPath(qself),
4498 .map(|mut e| e.emit());
4503 // Write back the new resolution.
4504 self.write_resolution(hir_id, result);
4506 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4508 slice::from_ref(&**item_segment),
4512 pub fn check_decl_initializer(
4514 local: &'tcx hir::Local<'tcx>,
4515 init: &'tcx hir::Expr<'tcx>,
4517 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4518 // for #42640 (default match binding modes).
4521 let ref_bindings = local.pat.contains_explicit_ref_binding();
4523 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4524 if let Some(m) = ref_bindings {
4525 // Somewhat subtle: if we have a `ref` binding in the pattern,
4526 // we want to avoid introducing coercions for the RHS. This is
4527 // both because it helps preserve sanity and, in the case of
4528 // ref mut, for soundness (issue #23116). In particular, in
4529 // the latter case, we need to be clear that the type of the
4530 // referent for the reference that results is *equal to* the
4531 // type of the place it is referencing, and not some
4532 // supertype thereof.
4533 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4534 self.demand_eqtype(init.span, local_ty, init_ty);
4537 self.check_expr_coercable_to_type(init, local_ty)
4541 /// Type check a `let` statement.
4542 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4543 // Determine and write the type which we'll check the pattern against.
4544 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4545 self.write_ty(local.hir_id, ty);
4547 // Type check the initializer.
4548 if let Some(ref init) = local.init {
4549 let init_ty = self.check_decl_initializer(local, &init);
4550 self.overwrite_local_ty_if_err(local, ty, init_ty);
4553 // Does the expected pattern type originate from an expression and what is the span?
4554 let (origin_expr, ty_span) = match (local.ty, local.init) {
4555 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4556 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4557 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4560 // Type check the pattern. Override if necessary to avoid knock-on errors.
4561 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4562 let pat_ty = self.node_ty(local.pat.hir_id);
4563 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4566 fn overwrite_local_ty_if_err(
4568 local: &'tcx hir::Local<'tcx>,
4572 if ty.references_error() {
4573 // Override the types everywhere with `types.err` to avoid knock on errors.
4574 self.write_ty(local.hir_id, ty);
4575 self.write_ty(local.pat.hir_id, ty);
4576 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4577 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4578 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4582 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4583 err.span_suggestion_short(
4584 span.shrink_to_hi(),
4585 "consider using a semicolon here",
4587 Applicability::MachineApplicable,
4591 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4592 // Don't do all the complex logic below for `DeclItem`.
4594 hir::StmtKind::Item(..) => return,
4595 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4598 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4600 // Hide the outer diverging and `has_errors` flags.
4601 let old_diverges = self.diverges.replace(Diverges::Maybe);
4602 let old_has_errors = self.has_errors.replace(false);
4605 hir::StmtKind::Local(ref l) => {
4606 self.check_decl_local(&l);
4609 hir::StmtKind::Item(_) => {}
4610 hir::StmtKind::Expr(ref expr) => {
4611 // Check with expected type of `()`.
4612 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4613 self.suggest_semicolon_at_end(expr.span, err);
4616 hir::StmtKind::Semi(ref expr) => {
4617 self.check_expr(&expr);
4621 // Combine the diverging and `has_error` flags.
4622 self.diverges.set(self.diverges.get() | old_diverges);
4623 self.has_errors.set(self.has_errors.get() | old_has_errors);
4626 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4627 let unit = self.tcx.mk_unit();
4628 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4630 // if the block produces a `!` value, that can always be
4631 // (effectively) coerced to unit.
4633 self.demand_suptype(blk.span, unit, ty);
4637 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4638 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4639 /// when given code like the following:
4641 /// if false { return 0i32; } else { 1u32 }
4642 /// // ^^^^ point at this instead of the whole `if` expression
4644 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4645 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4646 let arm_spans: Vec<Span> = arms
4649 self.in_progress_tables
4650 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4651 .and_then(|arm_ty| {
4652 if arm_ty.is_never() {
4655 Some(match &arm.body.kind {
4656 // Point at the tail expression when possible.
4657 hir::ExprKind::Block(block, _) => {
4658 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4666 if arm_spans.len() == 1 {
4667 return arm_spans[0];
4673 fn check_block_with_expected(
4675 blk: &'tcx hir::Block<'tcx>,
4676 expected: Expectation<'tcx>,
4679 let mut fcx_ps = self.ps.borrow_mut();
4680 let unsafety_state = fcx_ps.recurse(blk);
4681 replace(&mut *fcx_ps, unsafety_state)
4684 // In some cases, blocks have just one exit, but other blocks
4685 // can be targeted by multiple breaks. This can happen both
4686 // with labeled blocks as well as when we desugar
4687 // a `try { ... }` expression.
4691 // 'a: { if true { break 'a Err(()); } Ok(()) }
4693 // Here we would wind up with two coercions, one from
4694 // `Err(())` and the other from the tail expression
4695 // `Ok(())`. If the tail expression is omitted, that's a
4696 // "forced unit" -- unless the block diverges, in which
4697 // case we can ignore the tail expression (e.g., `'a: {
4698 // break 'a 22; }` would not force the type of the block
4700 let tail_expr = blk.expr.as_ref();
4701 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4702 let coerce = if blk.targeted_by_break {
4703 CoerceMany::new(coerce_to_ty)
4705 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4706 Some(e) => slice::from_ref(e),
4709 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4712 let prev_diverges = self.diverges.get();
4713 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4715 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4716 for s in blk.stmts {
4720 // check the tail expression **without** holding the
4721 // `enclosing_breakables` lock below.
4722 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4724 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4725 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4726 let coerce = ctxt.coerce.as_mut().unwrap();
4727 if let Some(tail_expr_ty) = tail_expr_ty {
4728 let tail_expr = tail_expr.unwrap();
4729 let span = self.get_expr_coercion_span(tail_expr);
4730 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4731 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4733 // Subtle: if there is no explicit tail expression,
4734 // that is typically equivalent to a tail expression
4735 // of `()` -- except if the block diverges. In that
4736 // case, there is no value supplied from the tail
4737 // expression (assuming there are no other breaks,
4738 // this implies that the type of the block will be
4741 // #41425 -- label the implicit `()` as being the
4742 // "found type" here, rather than the "expected type".
4743 if !self.diverges.get().is_always() {
4744 // #50009 -- Do not point at the entire fn block span, point at the return type
4745 // span, as it is the cause of the requirement, and
4746 // `consider_hint_about_removing_semicolon` will point at the last expression
4747 // if it were a relevant part of the error. This improves usability in editors
4748 // that highlight errors inline.
4749 let mut sp = blk.span;
4750 let mut fn_span = None;
4751 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4752 let ret_sp = decl.output.span();
4753 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4754 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4755 // output would otherwise be incorrect and even misleading. Make sure
4756 // the span we're aiming at correspond to a `fn` body.
4757 if block_sp == blk.span {
4759 fn_span = Some(ident.span);
4763 coerce.coerce_forced_unit(
4767 if let Some(expected_ty) = expected.only_has_type(self) {
4768 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4770 if let Some(fn_span) = fn_span {
4773 "implicitly returns `()` as its body has no tail or `return` \
4785 // If we can break from the block, then the block's exit is always reachable
4786 // (... as long as the entry is reachable) - regardless of the tail of the block.
4787 self.diverges.set(prev_diverges);
4790 let mut ty = ctxt.coerce.unwrap().complete(self);
4792 if self.has_errors.get() || ty.references_error() {
4793 ty = self.tcx.types.err
4796 self.write_ty(blk.hir_id, ty);
4798 *self.ps.borrow_mut() = prev;
4802 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4803 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4805 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4806 | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
4807 let body = self.tcx.hir().body(body_id);
4808 if let ExprKind::Block(block, _) = &body.value.kind {
4809 return Some(block.span);
4817 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4818 fn get_parent_fn_decl(
4821 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident)> {
4822 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4823 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4826 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4827 fn get_node_fn_decl(
4830 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident, bool)> {
4832 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4833 // This is less than ideal, it will not suggest a return type span on any
4834 // method called `main`, regardless of whether it is actually the entry point,
4835 // but it will still present it as the reason for the expected type.
4836 Some((&sig.decl, ident, ident.name != sym::main))
4838 Node::TraitItem(&hir::TraitItem {
4840 kind: hir::TraitItemKind::Fn(ref sig, ..),
4842 }) => Some((&sig.decl, ident, true)),
4843 Node::ImplItem(&hir::ImplItem {
4845 kind: hir::ImplItemKind::Fn(ref sig, ..),
4847 }) => Some((&sig.decl, ident, false)),
4852 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4853 /// suggestion can be made, `None` otherwise.
4854 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4855 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4856 // `while` before reaching it, as block tail returns are not available in them.
4857 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4858 let parent = self.tcx.hir().get(blk_id);
4859 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4863 /// On implicit return expressions with mismatched types, provides the following suggestions:
4865 /// - Points out the method's return type as the reason for the expected type.
4866 /// - Possible missing semicolon.
4867 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4868 pub fn suggest_mismatched_types_on_tail(
4870 err: &mut DiagnosticBuilder<'_>,
4871 expr: &'tcx hir::Expr<'tcx>,
4877 let expr = expr.peel_drop_temps();
4878 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4879 let mut pointing_at_return_type = false;
4880 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4881 pointing_at_return_type =
4882 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4884 pointing_at_return_type
4887 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4888 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4890 /// fn foo(x: usize) -> usize { x }
4891 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4895 err: &mut DiagnosticBuilder<'_>,
4896 expr: &hir::Expr<'_>,
4900 let hir = self.tcx.hir();
4901 let (def_id, sig) = match found.kind {
4902 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4903 ty::Closure(def_id, substs) => (def_id, substs.as_closure().sig()),
4907 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4908 let sig = self.normalize_associated_types_in(expr.span, &sig);
4909 if self.can_coerce(sig.output(), expected) {
4910 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4911 (String::new(), Applicability::MachineApplicable)
4913 ("...".to_string(), Applicability::HasPlaceholders)
4915 let mut msg = "call this function";
4916 match hir.get_if_local(def_id) {
4918 Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. })
4919 | Node::ImplItem(hir::ImplItem {
4920 kind: hir::ImplItemKind::Fn(_, body_id), ..
4922 | Node::TraitItem(hir::TraitItem {
4923 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Provided(body_id)),
4927 let body = hir.body(*body_id);
4931 .map(|param| match ¶m.pat.kind {
4932 hir::PatKind::Binding(_, _, ident, None)
4933 if ident.name != kw::SelfLower =>
4937 _ => "_".to_string(),
4939 .collect::<Vec<_>>()
4942 Some(Node::Expr(hir::Expr {
4943 kind: ExprKind::Closure(_, _, body_id, _, _),
4944 span: full_closure_span,
4947 if *full_closure_span == expr.span {
4950 msg = "call this closure";
4951 let body = hir.body(*body_id);
4955 .map(|param| match ¶m.pat.kind {
4956 hir::PatKind::Binding(_, _, ident, None)
4957 if ident.name != kw::SelfLower =>
4961 _ => "_".to_string(),
4963 .collect::<Vec<_>>()
4966 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4967 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4968 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4969 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4970 msg = "instantiate this tuple variant";
4972 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4973 msg = "instantiate this tuple struct";
4978 Some(Node::ForeignItem(hir::ForeignItem {
4979 kind: hir::ForeignItemKind::Fn(_, idents, _),
4985 if ident.name != kw::SelfLower {
4991 .collect::<Vec<_>>()
4994 Some(Node::TraitItem(hir::TraitItem {
4995 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Required(idents)),
5001 if ident.name != kw::SelfLower {
5007 .collect::<Vec<_>>()
5012 err.span_suggestion_verbose(
5013 expr.span.shrink_to_hi(),
5014 &format!("use parentheses to {}", msg),
5015 format!("({})", sugg_call),
5023 pub fn suggest_ref_or_into(
5025 err: &mut DiagnosticBuilder<'_>,
5026 expr: &hir::Expr<'_>,
5030 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
5031 err.span_suggestion(sp, msg, suggestion, Applicability::MachineApplicable);
5032 } else if let (ty::FnDef(def_id, ..), true) =
5033 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
5035 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
5036 let sp = self.sess().source_map().guess_head_span(sp);
5037 err.span_label(sp, &format!("{} defined here", found));
5039 } else if !self.check_for_cast(err, expr, found, expected) {
5040 let is_struct_pat_shorthand_field =
5041 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
5042 let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
5043 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5044 let mut suggestions = iter::repeat(&expr_text)
5045 .zip(methods.iter())
5046 .filter_map(|(receiver, method)| {
5047 let method_call = format!(".{}()", method.ident);
5048 if receiver.ends_with(&method_call) {
5049 None // do not suggest code that is already there (#53348)
5051 let method_call_list = [".to_vec()", ".to_string()"];
5052 let sugg = if receiver.ends_with(".clone()")
5053 && method_call_list.contains(&method_call.as_str())
5055 let max_len = receiver.rfind('.').unwrap();
5056 format!("{}{}", &receiver[..max_len], method_call)
5058 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
5059 format!("({}){}", receiver, method_call)
5061 format!("{}{}", receiver, method_call)
5064 Some(if is_struct_pat_shorthand_field {
5065 format!("{}: {}", receiver, sugg)
5072 if suggestions.peek().is_some() {
5073 err.span_suggestions(
5075 "try using a conversion method",
5077 Applicability::MaybeIncorrect,
5084 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
5085 /// in the heap by calling `Box::new()`.
5086 fn suggest_boxing_when_appropriate(
5088 err: &mut DiagnosticBuilder<'_>,
5089 expr: &hir::Expr<'_>,
5093 if self.tcx.hir().is_const_context(expr.hir_id) {
5094 // Do not suggest `Box::new` in const context.
5097 if !expected.is_box() || found.is_box() {
5100 let boxed_found = self.tcx.mk_box(found);
5101 if let (true, Ok(snippet)) = (
5102 self.can_coerce(boxed_found, expected),
5103 self.sess().source_map().span_to_snippet(expr.span),
5105 err.span_suggestion(
5107 "store this in the heap by calling `Box::new`",
5108 format!("Box::new({})", snippet),
5109 Applicability::MachineApplicable,
5112 "for more on the distinction between the stack and the heap, read \
5113 https://doc.rust-lang.org/book/ch15-01-box.html, \
5114 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
5115 https://doc.rust-lang.org/std/boxed/index.html",
5120 /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
5121 fn suggest_calling_boxed_future_when_appropriate(
5123 err: &mut DiagnosticBuilder<'_>,
5124 expr: &hir::Expr<'_>,
5130 if self.tcx.hir().is_const_context(expr.hir_id) {
5131 // Do not suggest `Box::new` in const context.
5134 let pin_did = self.tcx.lang_items().pin_type();
5135 match expected.kind {
5136 ty::Adt(def, _) if Some(def.did) != pin_did => return false,
5137 // This guards the `unwrap` and `mk_box` below.
5138 _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
5141 let boxed_found = self.tcx.mk_box(found);
5142 let new_found = self.tcx.mk_lang_item(boxed_found, lang_items::PinTypeLangItem).unwrap();
5143 if let (true, Ok(snippet)) = (
5144 self.can_coerce(new_found, expected),
5145 self.sess().source_map().span_to_snippet(expr.span),
5148 ty::Adt(def, _) if def.is_box() => {
5149 err.help("use `Box::pin`");
5152 err.span_suggestion(
5154 "you need to pin and box this expression",
5155 format!("Box::pin({})", snippet),
5156 Applicability::MachineApplicable,
5166 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5170 /// bar_that_returns_u32()
5174 /// This routine checks if the return expression in a block would make sense on its own as a
5175 /// statement and the return type has been left as default or has been specified as `()`. If so,
5176 /// it suggests adding a semicolon.
5177 fn suggest_missing_semicolon(
5179 err: &mut DiagnosticBuilder<'_>,
5180 expression: &'tcx hir::Expr<'tcx>,
5184 if expected.is_unit() {
5185 // `BlockTailExpression` only relevant if the tail expr would be
5186 // useful on its own.
5187 match expression.kind {
5189 | ExprKind::MethodCall(..)
5190 | ExprKind::Loop(..)
5191 | ExprKind::Match(..)
5192 | ExprKind::Block(..) => {
5193 err.span_suggestion(
5194 cause_span.shrink_to_hi(),
5195 "try adding a semicolon",
5197 Applicability::MachineApplicable,
5205 /// A possible error is to forget to add a return type that is needed:
5209 /// bar_that_returns_u32()
5213 /// This routine checks if the return type is left as default, the method is not part of an
5214 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5216 fn suggest_missing_return_type(
5218 err: &mut DiagnosticBuilder<'_>,
5219 fn_decl: &hir::FnDecl<'_>,
5224 // Only suggest changing the return type for methods that
5225 // haven't set a return type at all (and aren't `fn main()` or an impl).
5226 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5227 (&hir::FnRetTy::DefaultReturn(span), true, true, true) => {
5228 err.span_suggestion(
5230 "try adding a return type",
5231 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5232 Applicability::MachineApplicable,
5236 (&hir::FnRetTy::DefaultReturn(span), false, true, true) => {
5237 err.span_label(span, "possibly return type missing here?");
5240 (&hir::FnRetTy::DefaultReturn(span), _, false, true) => {
5241 // `fn main()` must return `()`, do not suggest changing return type
5242 err.span_label(span, "expected `()` because of default return type");
5245 // expectation was caused by something else, not the default return
5246 (&hir::FnRetTy::DefaultReturn(_), _, _, false) => false,
5247 (&hir::FnRetTy::Return(ref ty), _, _, _) => {
5248 // Only point to return type if the expected type is the return type, as if they
5249 // are not, the expectation must have been caused by something else.
5250 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5252 let ty = AstConv::ast_ty_to_ty(self, ty);
5253 debug!("suggest_missing_return_type: return type {:?}", ty);
5254 debug!("suggest_missing_return_type: expected type {:?}", ty);
5255 if ty.kind == expected.kind {
5256 err.span_label(sp, format!("expected `{}` because of return type", expected));
5264 /// A possible error is to forget to add `.await` when using futures:
5267 /// async fn make_u32() -> u32 {
5271 /// fn take_u32(x: u32) {}
5273 /// async fn foo() {
5274 /// let x = make_u32();
5279 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5280 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5281 /// `.await` to the tail of the expression.
5282 fn suggest_missing_await(
5284 err: &mut DiagnosticBuilder<'_>,
5285 expr: &hir::Expr<'_>,
5289 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5290 // body isn't `async`.
5291 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5292 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5293 let body = self.tcx().hir().body(body_id);
5294 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5296 // Check for `Future` implementations by constructing a predicate to
5297 // prove: `<T as Future>::Output == U`
5298 let future_trait = self.tcx.lang_items().future_trait().unwrap();
5299 let item_def_id = self
5301 .associated_items(future_trait)
5302 .in_definition_order()
5307 ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5308 // `<T as Future>::Output`
5309 projection_ty: ty::ProjectionTy {
5311 substs: self.tcx.mk_substs_trait(
5313 self.fresh_substs_for_item(sp, item_def_id),
5320 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5321 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5322 if self.infcx.predicate_may_hold(&obligation) {
5323 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5324 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5325 err.span_suggestion(
5327 "consider using `.await` here",
5328 format!("{}.await", code),
5329 Applicability::MaybeIncorrect,
5332 debug!("suggest_missing_await: no snippet for {:?}", sp);
5335 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5341 /// A common error is to add an extra semicolon:
5344 /// fn foo() -> usize {
5349 /// This routine checks if the final statement in a block is an
5350 /// expression with an explicit semicolon whose type is compatible
5351 /// with `expected_ty`. If so, it suggests removing the semicolon.
5352 fn consider_hint_about_removing_semicolon(
5354 blk: &'tcx hir::Block<'tcx>,
5355 expected_ty: Ty<'tcx>,
5356 err: &mut DiagnosticBuilder<'_>,
5358 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5359 err.span_suggestion(
5361 "consider removing this semicolon",
5363 Applicability::MachineApplicable,
5368 fn could_remove_semicolon(
5370 blk: &'tcx hir::Block<'tcx>,
5371 expected_ty: Ty<'tcx>,
5373 // Be helpful when the user wrote `{... expr;}` and
5374 // taking the `;` off is enough to fix the error.
5375 let last_stmt = blk.stmts.last()?;
5376 let last_expr = match last_stmt.kind {
5377 hir::StmtKind::Semi(ref e) => e,
5380 let last_expr_ty = self.node_ty(last_expr.hir_id);
5381 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5384 let original_span = original_sp(last_stmt.span, blk.span);
5385 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5388 // Instantiates the given path, which must refer to an item with the given
5389 // number of type parameters and type.
5390 pub fn instantiate_value_path(
5392 segments: &[hir::PathSegment<'_>],
5393 self_ty: Option<Ty<'tcx>>,
5397 ) -> (Ty<'tcx>, Res) {
5399 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5400 segments, self_ty, res, hir_id,
5405 let path_segs = match res {
5406 Res::Local(_) | Res::SelfCtor(_) => vec![],
5407 Res::Def(kind, def_id) => {
5408 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5410 _ => bug!("instantiate_value_path on {:?}", res),
5413 let mut user_self_ty = None;
5414 let mut is_alias_variant_ctor = false;
5416 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5417 if let Some(self_ty) = self_ty {
5418 let adt_def = self_ty.ty_adt_def().unwrap();
5419 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5420 is_alias_variant_ctor = true;
5423 Res::Def(DefKind::AssocFn | DefKind::AssocConst, def_id) => {
5424 let container = tcx.associated_item(def_id).container;
5425 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5427 ty::TraitContainer(trait_did) => {
5428 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5430 ty::ImplContainer(impl_def_id) => {
5431 if segments.len() == 1 {
5432 // `<T>::assoc` will end up here, and so
5433 // can `T::assoc`. It this came from an
5434 // inherent impl, we need to record the
5435 // `T` for posterity (see `UserSelfTy` for
5437 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5438 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5446 // Now that we have categorized what space the parameters for each
5447 // segment belong to, let's sort out the parameters that the user
5448 // provided (if any) into their appropriate spaces. We'll also report
5449 // errors if type parameters are provided in an inappropriate place.
5451 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5452 let generics_has_err = AstConv::prohibit_generics(
5454 segments.iter().enumerate().filter_map(|(index, seg)| {
5455 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5463 if let Res::Local(hid) = res {
5464 let ty = self.local_ty(span, hid).decl_ty;
5465 let ty = self.normalize_associated_types_in(span, &ty);
5466 self.write_ty(hir_id, ty);
5470 if generics_has_err {
5471 // Don't try to infer type parameters when prohibited generic arguments were given.
5472 user_self_ty = None;
5475 // Now we have to compare the types that the user *actually*
5476 // provided against the types that were *expected*. If the user
5477 // did not provide any types, then we want to substitute inference
5478 // variables. If the user provided some types, we may still need
5479 // to add defaults. If the user provided *too many* types, that's
5482 let mut infer_args_for_err = FxHashSet::default();
5483 for &PathSeg(def_id, index) in &path_segs {
5484 let seg = &segments[index];
5485 let generics = tcx.generics_of(def_id);
5486 // Argument-position `impl Trait` is treated as a normal generic
5487 // parameter internally, but we don't allow users to specify the
5488 // parameter's value explicitly, so we have to do some error-
5490 if let Err(GenericArgCountMismatch { reported: Some(ErrorReported), .. }) =
5491 AstConv::check_generic_arg_count_for_call(
5492 tcx, span, &generics, &seg, false, // `is_method_call`
5495 infer_args_for_err.insert(index);
5496 self.set_tainted_by_errors(); // See issue #53251.
5500 let has_self = path_segs
5502 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5505 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5506 let ty = self.normalize_ty(span, tcx.at(span).type_of(impl_def_id));
5508 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5509 let variant = adt_def.non_enum_variant();
5510 let ctor_def_id = variant.ctor_def_id.unwrap();
5512 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5517 let mut err = tcx.sess.struct_span_err(
5519 "the `Self` constructor can only be used with tuple or unit structs",
5521 if let Some(adt_def) = ty.ty_adt_def() {
5522 match adt_def.adt_kind() {
5524 err.help("did you mean to use one of the enum's variants?");
5526 AdtKind::Struct | AdtKind::Union => {
5527 err.span_suggestion(
5529 "use curly brackets",
5530 String::from("Self { /* fields */ }"),
5531 Applicability::HasPlaceholders,
5538 return (tcx.types.err, res);
5544 let def_id = res.def_id();
5546 // The things we are substituting into the type should not contain
5547 // escaping late-bound regions, and nor should the base type scheme.
5548 let ty = tcx.type_of(def_id);
5550 let substs = self_ctor_substs.unwrap_or_else(|| {
5551 AstConv::create_substs_for_generic_args(
5557 infer_args_for_err.is_empty(),
5558 // Provide the generic args, and whether types should be inferred.
5560 if let Some(&PathSeg(_, index)) =
5561 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5563 // If we've encountered an `impl Trait`-related error, we're just
5564 // going to infer the arguments for better error messages.
5565 if !infer_args_for_err.contains(&index) {
5566 // Check whether the user has provided generic arguments.
5567 if let Some(ref data) = segments[index].args {
5568 return (Some(data), segments[index].infer_args);
5571 return (None, segments[index].infer_args);
5576 // Provide substitutions for parameters for which (valid) arguments have been provided.
5577 |param, arg| match (¶m.kind, arg) {
5578 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5579 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5581 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5582 self.to_ty(ty).into()
5584 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5585 self.to_const(&ct.value).into()
5587 _ => unreachable!(),
5589 // Provide substitutions for parameters for which arguments are inferred.
5590 |substs, param, infer_args| {
5592 GenericParamDefKind::Lifetime => {
5593 self.re_infer(Some(param), span).unwrap().into()
5595 GenericParamDefKind::Type { has_default, .. } => {
5596 if !infer_args && has_default {
5597 // If we have a default, then we it doesn't matter that we're not
5598 // inferring the type arguments: we provide the default where any
5600 let default = tcx.type_of(param.def_id);
5603 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5607 // If no type arguments were provided, we have to infer them.
5608 // This case also occurs as a result of some malformed input, e.g.
5609 // a lifetime argument being given instead of a type parameter.
5610 // Using inference instead of `Error` gives better error messages.
5611 self.var_for_def(span, param)
5614 GenericParamDefKind::Const => {
5615 // FIXME(const_generics:defaults)
5616 // No const parameters were provided, we have to infer them.
5617 self.var_for_def(span, param)
5623 assert!(!substs.has_escaping_bound_vars());
5624 assert!(!ty.has_escaping_bound_vars());
5626 // First, store the "user substs" for later.
5627 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5629 self.add_required_obligations(span, def_id, &substs);
5631 // Substitute the values for the type parameters into the type of
5632 // the referenced item.
5633 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5635 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5636 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5637 // is inherent, there is no `Self` parameter; instead, the impl needs
5638 // type parameters, which we can infer by unifying the provided `Self`
5639 // with the substituted impl type.
5640 // This also occurs for an enum variant on a type alias.
5641 let ty = tcx.type_of(impl_def_id);
5643 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5644 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5645 Ok(ok) => self.register_infer_ok_obligations(ok),
5647 self.tcx.sess.delay_span_bug(
5650 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5659 self.check_rustc_args_require_const(def_id, hir_id, span);
5661 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5662 self.write_substs(hir_id, substs);
5664 (ty_substituted, res)
5667 /// Add all the obligations that are required, substituting and normalized appropriately.
5668 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5669 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5671 for (i, mut obligation) in traits::predicates_for_generics(
5672 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5679 // This makes the error point at the bound, but we want to point at the argument
5680 if let Some(span) = spans.get(i) {
5681 obligation.cause.code = traits::BindingObligation(def_id, *span);
5683 self.register_predicate(obligation);
5687 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5688 // We're only interested in functions tagged with
5689 // #[rustc_args_required_const], so ignore anything that's not.
5690 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5694 // If our calling expression is indeed the function itself, we're good!
5695 // If not, generate an error that this can only be called directly.
5696 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5697 if let ExprKind::Call(ref callee, ..) = expr.kind {
5698 if callee.hir_id == hir_id {
5704 self.tcx.sess.span_err(
5706 "this function can only be invoked directly, not through a function pointer",
5710 /// Resolves `typ` by a single level if `typ` is a type variable.
5711 /// If no resolution is possible, then an error is reported.
5712 /// Numeric inference variables may be left unresolved.
5713 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5714 let ty = self.resolve_vars_with_obligations(ty);
5715 if !ty.is_ty_var() {
5718 if !self.is_tainted_by_errors() {
5719 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5720 .note("type must be known at this point")
5723 self.demand_suptype(sp, self.tcx.types.err, ty);
5728 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5731 ctxt: BreakableCtxt<'tcx>,
5733 ) -> (BreakableCtxt<'tcx>, R) {
5736 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5737 index = enclosing_breakables.stack.len();
5738 enclosing_breakables.by_id.insert(id, index);
5739 enclosing_breakables.stack.push(ctxt);
5743 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5744 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5745 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5746 enclosing_breakables.stack.pop().expect("missing breakable context")
5751 /// Instantiate a QueryResponse in a probe context, without a
5752 /// good ObligationCause.
5753 fn probe_instantiate_query_response(
5756 original_values: &OriginalQueryValues<'tcx>,
5757 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5758 ) -> InferResult<'tcx, Ty<'tcx>> {
5759 self.instantiate_query_response_and_region_obligations(
5760 &traits::ObligationCause::misc(span, self.body_id),
5767 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5768 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5769 let mut contained_in_place = false;
5771 while let hir::Node::Expr(parent_expr) =
5772 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5774 match &parent_expr.kind {
5775 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5776 if lhs.hir_id == expr_id {
5777 contained_in_place = true;
5783 expr_id = parent_expr.hir_id;
5790 fn check_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5791 debug!("check_type_params_are_used(generics={:?}, ty={:?})", generics, ty);
5793 assert_eq!(generics.parent, None);
5795 if generics.own_counts().types == 0 {
5799 let mut params_used = BitSet::new_empty(generics.params.len());
5801 if ty.references_error() {
5802 // If there is already another error, do not emit
5803 // an error for not using a type parameter.
5804 assert!(tcx.sess.has_errors());
5808 for leaf in ty.walk() {
5809 if let GenericArgKind::Type(leaf_ty) = leaf.unpack() {
5810 if let ty::Param(param) = leaf_ty.kind {
5811 debug!("found use of ty param {:?}", param);
5812 params_used.insert(param.index);
5817 for param in &generics.params {
5818 if !params_used.contains(param.index) {
5819 if let ty::GenericParamDefKind::Type { .. } = param.kind {
5820 let span = tcx.def_span(param.def_id);
5825 "type parameter `{}` is unused",
5828 .span_label(span, "unused type parameter")
5835 fn fatally_break_rust(sess: &Session) {
5836 let handler = sess.diagnostic();
5837 handler.span_bug_no_panic(
5839 "It looks like you're trying to break rust; would you like some ICE?",
5841 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5842 handler.note_without_error(
5843 "we would appreciate a joke overview: \
5844 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5846 handler.note_without_error(&format!(
5847 "rustc {} running on {}",
5848 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5849 config::host_triple(),
5853 fn potentially_plural_count(count: usize, word: &str) -> String {
5854 format!("{} {}{}", count, word, pluralize!(count))