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 - writeback: writes the final types within a function body, replacing
35 type variables with their final inferred types. These final types
36 are written into the `tcx.node_types` table, which should *never* contain
37 any reference to a type variable.
41 While type checking a function, the intermediate types for the
42 expressions, blocks, and so forth contained within the function are
43 stored in `fcx.node_types` and `fcx.node_substs`. These types
44 may contain unresolved type variables. After type checking is
45 complete, the functions in the writeback module are used to take the
46 types from this table, resolve them, and then write them into their
47 permanent home in the type context `tcx`.
49 This means that during inferencing you should use `fcx.write_ty()`
50 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
51 nodes within the function.
53 The types of top-level items, which never contain unbound type
54 variables, are stored directly into the `tcx` tables.
56 N.B., a type variable is not the same thing as a type parameter. A
57 type variable is rather an "instance" of a type parameter: that is,
58 given a generic function `fn foo<T>(t: T)`: while checking the
59 function `foo`, the type `ty_param(0)` refers to the type `T`, which
60 is treated in abstract. When `foo()` is called, however, `T` will be
61 substituted for a fresh type variable `N`. This variable will
62 eventually be resolved to some concrete type (which might itself be
77 mod generator_interior;
89 AstConv, ExplicitLateBound, GenericArgCountMismatch, GenericArgCountResult, 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, LocalDefId, LOCAL_CRATE};
101 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
102 use rustc_hir::itemlikevisit::ItemLikeVisitor;
103 use rustc_hir::lang_items::{
104 FutureTraitLangItem, PinTypeLangItem, SizedTraitLangItem, VaListTypeLangItem,
106 use rustc_hir::{ExprKind, GenericArg, HirIdMap, ItemKind, Node, PatKind, QPath};
107 use rustc_index::bit_set::BitSet;
108 use rustc_index::vec::Idx;
109 use rustc_infer::infer;
110 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
111 use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
112 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
113 use rustc_infer::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
114 use rustc_infer::infer::{InferCtxt, InferOk, InferResult, RegionVariableOrigin, TyCtxtInferExt};
115 use rustc_middle::hir::map::blocks::FnLikeNode;
116 use rustc_middle::mir::interpret::ConstValue;
117 use rustc_middle::ty::adjustment::{
118 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
120 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder};
121 use rustc_middle::ty::query::Providers;
122 use rustc_middle::ty::subst::{self, InternalSubsts, Subst, SubstsRef};
123 use rustc_middle::ty::subst::{GenericArgKind, UserSelfTy, UserSubsts};
124 use rustc_middle::ty::util::{Discr, IntTypeExt, Representability};
125 use rustc_middle::ty::{
126 self, AdtKind, CanonicalUserType, Const, GenericParamDefKind, RegionKind, ToPolyTraitRef,
127 ToPredicate, Ty, TyCtxt, UserType, WithConstness,
129 use rustc_session::config::{self, EntryFnType};
130 use rustc_session::lint;
131 use rustc_session::parse::feature_err;
132 use rustc_session::Session;
133 use rustc_span::hygiene::DesugaringKind;
134 use rustc_span::source_map::{original_sp, DUMMY_SP};
135 use rustc_span::symbol::{kw, sym, Ident};
136 use rustc_span::{self, BytePos, MultiSpan, Span};
137 use rustc_target::abi::VariantIdx;
138 use rustc_target::spec::abi::Abi;
139 use rustc_trait_selection::infer::InferCtxtExt as _;
140 use rustc_trait_selection::opaque_types::{InferCtxtExt as _, OpaqueTypeDecl};
141 use rustc_trait_selection::traits::error_reporting::recursive_type_with_infinite_size_error;
142 use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;
143 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
144 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
145 use rustc_trait_selection::traits::{
146 self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt,
149 use std::cell::{Cell, Ref, RefCell, RefMut};
151 use std::collections::hash_map::Entry;
153 use std::mem::replace;
154 use std::ops::{self, Deref};
157 use crate::require_c_abi_if_c_variadic;
158 use crate::util::common::indenter;
160 use self::callee::DeferredCallResolution;
161 use self::coercion::{CoerceMany, DynamicCoerceMany};
162 use self::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
163 use self::method::{MethodCallee, SelfSource};
164 pub use self::Expectation::*;
165 use self::TupleArgumentsFlag::*;
168 macro_rules! type_error_struct {
169 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
170 if $typ.references_error() {
171 $session.diagnostic().struct_dummy()
173 rustc_errors::struct_span_err!($session, $span, $code, $($message)*)
178 /// The type of a local binding, including the revealed type for anon types.
179 #[derive(Copy, Clone, Debug)]
180 pub struct LocalTy<'tcx> {
182 revealed_ty: Ty<'tcx>,
185 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
186 #[derive(Copy, Clone)]
187 struct MaybeInProgressTables<'a, 'tcx> {
188 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
191 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
192 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
193 match self.maybe_tables {
194 Some(tables) => tables.borrow(),
195 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables"),
199 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
200 match self.maybe_tables {
201 Some(tables) => tables.borrow_mut(),
202 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables"),
207 /// Closures defined within the function. For example:
210 /// bar(move|| { ... })
213 /// Here, the function `foo()` and the closure passed to
214 /// `bar()` will each have their own `FnCtxt`, but they will
215 /// share the inherited fields.
216 pub struct Inherited<'a, 'tcx> {
217 infcx: InferCtxt<'a, 'tcx>,
219 tables: MaybeInProgressTables<'a, 'tcx>,
221 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
223 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
225 // Some additional `Sized` obligations badly affect type inference.
226 // These obligations are added in a later stage of typeck.
227 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
229 // When we process a call like `c()` where `c` is a closure type,
230 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
231 // `FnOnce` closure. In that case, we defer full resolution of the
232 // call until upvar inference can kick in and make the
233 // decision. We keep these deferred resolutions grouped by the
234 // def-id of the closure, so that once we decide, we can easily go
235 // back and process them.
236 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
238 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
240 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
242 // Opaque types found in explicit return types and their
243 // associated fresh inference variable. Writeback resolves these
244 // variables to get the concrete type, which can be used to
245 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
246 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
248 /// A map from inference variables created from opaque
249 /// type instantiations (`ty::Infer`) to the actual opaque
250 /// type (`ty::Opaque`). Used during fallback to map unconstrained
251 /// opaque type inference variables to their corresponding
253 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
255 /// Each type parameter has an implicit region bound that
256 /// indicates it must outlive at least the function body (the user
257 /// may specify stronger requirements). This field indicates the
258 /// region of the callee. If it is `None`, then the parameter
259 /// environment is for an item or something where the "callee" is
261 implicit_region_bound: Option<ty::Region<'tcx>>,
263 body_id: Option<hir::BodyId>,
266 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
267 type Target = InferCtxt<'a, 'tcx>;
268 fn deref(&self) -> &Self::Target {
273 /// When type-checking an expression, we propagate downward
274 /// whatever type hint we are able in the form of an `Expectation`.
275 #[derive(Copy, Clone, Debug)]
276 pub enum Expectation<'tcx> {
277 /// We know nothing about what type this expression should have.
280 /// This expression should have the type given (or some subtype).
281 ExpectHasType(Ty<'tcx>),
283 /// This expression will be cast to the `Ty`.
284 ExpectCastableToType(Ty<'tcx>),
286 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
287 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
288 ExpectRvalueLikeUnsized(Ty<'tcx>),
291 impl<'a, 'tcx> Expectation<'tcx> {
292 // Disregard "castable to" expectations because they
293 // can lead us astray. Consider for example `if cond
294 // {22} else {c} as u8` -- if we propagate the
295 // "castable to u8" constraint to 22, it will pick the
296 // type 22u8, which is overly constrained (c might not
297 // be a u8). In effect, the problem is that the
298 // "castable to" expectation is not the tightest thing
299 // we can say, so we want to drop it in this case.
300 // The tightest thing we can say is "must unify with
301 // else branch". Note that in the case of a "has type"
302 // constraint, this limitation does not hold.
304 // If the expected type is just a type variable, then don't use
305 // an expected type. Otherwise, we might write parts of the type
306 // when checking the 'then' block which are incompatible with the
308 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
310 ExpectHasType(ety) => {
311 let ety = fcx.shallow_resolve(ety);
312 if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
314 ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
319 /// Provides an expectation for an rvalue expression given an *optional*
320 /// hint, which is not required for type safety (the resulting type might
321 /// be checked higher up, as is the case with `&expr` and `box expr`), but
322 /// is useful in determining the concrete type.
324 /// The primary use case is where the expected type is a fat pointer,
325 /// like `&[isize]`. For example, consider the following statement:
327 /// let x: &[isize] = &[1, 2, 3];
329 /// In this case, the expected type for the `&[1, 2, 3]` expression is
330 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
331 /// expectation `ExpectHasType([isize])`, that would be too strong --
332 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
333 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
334 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
335 /// which still is useful, because it informs integer literals and the like.
336 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
337 /// for examples of where this comes up,.
338 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
339 match fcx.tcx.struct_tail_without_normalization(ty).kind {
340 ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
341 _ => ExpectHasType(ty),
345 // Resolves `expected` by a single level if it is a variable. If
346 // there is no expected type or resolution is not possible (e.g.,
347 // no constraints yet present), just returns `None`.
348 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
350 NoExpectation => NoExpectation,
351 ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
352 ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
353 ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
357 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 NoExpectation => None,
360 ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
364 /// It sometimes happens that we want to turn an expectation into
365 /// a **hard constraint** (i.e., something that must be satisfied
366 /// for the program to type-check). `only_has_type` will return
367 /// such a constraint, if it exists.
368 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
369 match self.resolve(fcx) {
370 ExpectHasType(ty) => Some(ty),
371 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
375 /// Like `only_has_type`, but instead of returning `None` if no
376 /// hard constraint exists, creates a fresh type variable.
377 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
378 self.only_has_type(fcx).unwrap_or_else(|| {
379 fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
384 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
391 fn maybe_mut_place(m: hir::Mutability) -> Self {
393 hir::Mutability::Mut => Needs::MutPlace,
394 hir::Mutability::Not => Needs::None,
399 #[derive(Copy, Clone)]
400 pub struct UnsafetyState {
402 pub unsafety: hir::Unsafety,
403 pub unsafe_push_count: u32,
408 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
409 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
412 pub fn recurse(&mut self, blk: &hir::Block<'_>) -> UnsafetyState {
413 use hir::BlockCheckMode;
414 match self.unsafety {
415 // If this unsafe, then if the outer function was already marked as
416 // unsafe we shouldn't attribute the unsafe'ness to the block. This
417 // way the block can be warned about instead of ignoring this
418 // extraneous block (functions are never warned about).
419 hir::Unsafety::Unsafe if self.from_fn => *self,
422 let (unsafety, def, count) = match blk.rules {
423 BlockCheckMode::PushUnsafeBlock(..) => {
424 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
426 BlockCheckMode::PopUnsafeBlock(..) => {
427 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
429 BlockCheckMode::UnsafeBlock(..) => {
430 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
432 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
434 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
440 #[derive(Debug, Copy, Clone)]
446 /// Tracks whether executing a node may exit normally (versus
447 /// return/break/panic, which "diverge", leaving dead code in their
448 /// wake). Tracked semi-automatically (through type variables marked
449 /// as diverging), with some manual adjustments for control-flow
450 /// primitives (approximating a CFG).
451 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
453 /// Potentially unknown, some cases converge,
454 /// others require a CFG to determine them.
457 /// Definitely known to diverge and therefore
458 /// not reach the next sibling or its parent.
460 /// The `Span` points to the expression
461 /// that caused us to diverge
462 /// (e.g. `return`, `break`, etc).
464 /// In some cases (e.g. a `match` expression
465 /// where all arms diverge), we may be
466 /// able to provide a more informative
467 /// message to the user.
468 /// If this is `None`, a default message
469 /// will be generated, which is suitable
471 custom_note: Option<&'static str>,
474 /// Same as `Always` but with a reachability
475 /// warning already emitted.
479 // Convenience impls for combining `Diverges`.
481 impl ops::BitAnd for Diverges {
483 fn bitand(self, other: Self) -> Self {
484 cmp::min(self, other)
488 impl ops::BitOr for Diverges {
490 fn bitor(self, other: Self) -> Self {
491 cmp::max(self, other)
495 impl ops::BitAndAssign for Diverges {
496 fn bitand_assign(&mut self, other: Self) {
497 *self = *self & other;
501 impl ops::BitOrAssign for Diverges {
502 fn bitor_assign(&mut self, other: Self) {
503 *self = *self | other;
508 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
509 fn always(span: Span) -> Diverges {
510 Diverges::Always { span, custom_note: None }
513 fn is_always(self) -> bool {
514 // Enum comparison ignores the
515 // contents of fields, so we just
516 // fill them in with garbage here.
517 self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
521 pub struct BreakableCtxt<'tcx> {
524 // this is `null` for loops where break with a value is illegal,
525 // such as `while`, `for`, and `while let`
526 coerce: Option<DynamicCoerceMany<'tcx>>,
529 pub struct EnclosingBreakables<'tcx> {
530 stack: Vec<BreakableCtxt<'tcx>>,
531 by_id: HirIdMap<usize>,
534 impl<'tcx> EnclosingBreakables<'tcx> {
535 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
536 self.opt_find_breakable(target_id).unwrap_or_else(|| {
537 bug!("could not find enclosing breakable with id {}", target_id);
541 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
542 match self.by_id.get(&target_id) {
543 Some(ix) => Some(&mut self.stack[*ix]),
549 pub struct FnCtxt<'a, 'tcx> {
552 /// The parameter environment used for proving trait obligations
553 /// in this function. This can change when we descend into
554 /// closures (as they bring new things into scope), hence it is
555 /// not part of `Inherited` (as of the time of this writing,
556 /// closures do not yet change the environment, but they will
558 param_env: ty::ParamEnv<'tcx>,
560 /// Number of errors that had been reported when we started
561 /// checking this function. On exit, if we find that *more* errors
562 /// have been reported, we will skip regionck and other work that
563 /// expects the types within the function to be consistent.
564 // FIXME(matthewjasper) This should not exist, and it's not correct
565 // if type checking is run in parallel.
566 err_count_on_creation: usize,
568 /// If `Some`, this stores coercion information for returned
569 /// expressions. If `None`, this is in a context where return is
570 /// inappropriate, such as a const expression.
572 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
573 /// can track all the return expressions and then use them to
574 /// compute a useful coercion from the set, similar to a match
575 /// expression or other branching context. You can use methods
576 /// like `expected_ty` to access the declared return type (if
578 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
580 /// First span of a return site that we find. Used in error messages.
581 ret_coercion_span: RefCell<Option<Span>>,
583 resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>,
585 ps: RefCell<UnsafetyState>,
587 /// Whether the last checked node generates a divergence (e.g.,
588 /// `return` will set this to `Always`). In general, when entering
589 /// an expression or other node in the tree, the initial value
590 /// indicates whether prior parts of the containing expression may
591 /// have diverged. It is then typically set to `Maybe` (and the
592 /// old value remembered) for processing the subparts of the
593 /// current expression. As each subpart is processed, they may set
594 /// the flag to `Always`, etc. Finally, at the end, we take the
595 /// result and "union" it with the original value, so that when we
596 /// return the flag indicates if any subpart of the parent
597 /// expression (up to and including this part) has diverged. So,
598 /// if you read it after evaluating a subexpression `X`, the value
599 /// you get indicates whether any subexpression that was
600 /// evaluating up to and including `X` diverged.
602 /// We currently use this flag only for diagnostic purposes:
604 /// - To warn about unreachable code: if, after processing a
605 /// sub-expression but before we have applied the effects of the
606 /// current node, we see that the flag is set to `Always`, we
607 /// can issue a warning. This corresponds to something like
608 /// `foo(return)`; we warn on the `foo()` expression. (We then
609 /// update the flag to `WarnedAlways` to suppress duplicate
610 /// reports.) Similarly, if we traverse to a fresh statement (or
611 /// tail expression) from a `Always` setting, we will issue a
612 /// warning. This corresponds to something like `{return;
613 /// foo();}` or `{return; 22}`, where we would warn on the
616 /// An expression represents dead code if, after checking it,
617 /// the diverges flag is set to something other than `Maybe`.
618 diverges: Cell<Diverges>,
620 /// Whether any child nodes have any type errors.
621 has_errors: Cell<bool>,
623 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
625 inh: &'a Inherited<'a, 'tcx>,
628 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
629 type Target = Inherited<'a, 'tcx>;
630 fn deref(&self) -> &Self::Target {
635 /// Helper type of a temporary returned by `Inherited::build(...)`.
636 /// Necessary because we can't write the following bound:
637 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
638 pub struct InheritedBuilder<'tcx> {
639 infcx: infer::InferCtxtBuilder<'tcx>,
643 impl Inherited<'_, 'tcx> {
644 pub fn build(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> InheritedBuilder<'tcx> {
645 let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
648 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_owner),
654 impl<'tcx> InheritedBuilder<'tcx> {
655 fn enter<F, R>(&mut self, f: F) -> R
657 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
659 let def_id = self.def_id;
660 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
664 impl Inherited<'a, 'tcx> {
665 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
667 let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
668 let body_id = tcx.hir().maybe_body_owned_by(item_id);
671 tables: MaybeInProgressTables { maybe_tables: infcx.in_progress_tables },
673 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
674 locals: RefCell::new(Default::default()),
675 deferred_sized_obligations: RefCell::new(Vec::new()),
676 deferred_call_resolutions: RefCell::new(Default::default()),
677 deferred_cast_checks: RefCell::new(Vec::new()),
678 deferred_generator_interiors: RefCell::new(Vec::new()),
679 opaque_types: RefCell::new(Default::default()),
680 opaque_types_vars: RefCell::new(Default::default()),
681 implicit_region_bound: None,
686 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
687 debug!("register_predicate({:?})", obligation);
688 if obligation.has_escaping_bound_vars() {
689 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
691 self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
694 fn register_predicates<I>(&self, obligations: I)
696 I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
698 for obligation in obligations {
699 self.register_predicate(obligation);
703 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
704 self.register_predicates(infer_ok.obligations);
708 fn normalize_associated_types_in<T>(
712 param_env: ty::ParamEnv<'tcx>,
716 T: TypeFoldable<'tcx>,
718 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
719 self.register_infer_ok_obligations(ok)
723 struct CheckItemTypesVisitor<'tcx> {
727 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
728 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
729 check_item_type(self.tcx, i);
731 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
732 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
735 pub fn check_wf_new(tcx: TyCtxt<'_>) {
736 let visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
737 tcx.hir().krate().par_visit_all_item_likes(&visit);
740 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
741 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
744 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
745 debug_assert!(crate_num == LOCAL_CRATE);
746 tcx.par_body_owners(|body_owner_def_id| {
747 tcx.ensure().typeck_tables_of(body_owner_def_id);
751 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) {
752 wfcheck::check_item_well_formed(tcx, def_id);
755 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) {
756 wfcheck::check_trait_item(tcx, def_id);
759 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) {
760 wfcheck::check_impl_item(tcx, def_id);
763 pub fn provide(providers: &mut Providers) {
764 method::provide(providers);
765 *providers = Providers {
767 typeck_tables_of_const_arg,
769 diagnostic_only_typeck_tables_of,
773 check_item_well_formed,
774 check_trait_item_well_formed,
775 check_impl_item_well_formed,
776 check_mod_item_types,
781 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
782 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
785 /// If this `DefId` is a "primary tables entry", returns
786 /// `Some((body_id, header, decl))` with information about
787 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
790 /// If this function returns `Some`, then `typeck_tables(def_id)` will
791 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
792 /// may not succeed. In some cases where this function returns `None`
793 /// (notably closures), `typeck_tables(def_id)` would wind up
794 /// redirecting to the owning function.
798 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
799 match tcx.hir().get(id) {
800 Node::Item(item) => match item.kind {
801 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
802 Some((body, Some(ty), None, None))
804 hir::ItemKind::Fn(ref sig, .., body) => {
805 Some((body, None, Some(&sig.header), Some(&sig.decl)))
809 Node::TraitItem(item) => match item.kind {
810 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
811 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
812 Some((body, None, Some(&sig.header), Some(&sig.decl)))
816 Node::ImplItem(item) => match item.kind {
817 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
818 hir::ImplItemKind::Fn(ref sig, body) => {
819 Some((body, None, Some(&sig.header), Some(&sig.decl)))
823 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
828 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
829 // Closures' tables come from their outermost function,
830 // as they are part of the same "inference environment".
831 let outer_def_id = tcx.closure_base_def_id(def_id);
832 if outer_def_id != def_id {
833 return tcx.has_typeck_tables(outer_def_id);
836 if let Some(def_id) = def_id.as_local() {
837 let id = tcx.hir().local_def_id_to_hir_id(def_id);
838 primary_body_of(tcx, id).is_some()
844 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &FxHashSet<LocalDefId> {
845 &*tcx.typeck_tables_of(def_id).used_trait_imports
848 /// Inspects the substs of opaque types, replacing any inference variables
849 /// with proper generic parameter from the identity substs.
851 /// This is run after we normalize the function signature, to fix any inference
852 /// variables introduced by the projection of associated types. This ensures that
853 /// any opaque types used in the signature continue to refer to generic parameters,
854 /// allowing them to be considered for defining uses in the function body
856 /// For example, consider this code.
861 /// fn use_it(self) -> Self::MyItem
863 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
864 /// type MyItem = impl Iterator<Item = I>;
865 /// fn use_it(self) -> Self::MyItem {
871 /// When we normalize the signature of `use_it` from the impl block,
872 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
873 /// However, this projection result may contain inference variables, due
874 /// to the way that projection works. We didn't have any inference variables
875 /// in the signature to begin with - leaving them in will cause us to incorrectly
876 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
877 /// variables back to the actual generic parameters, we will correctly see that
878 /// we have a defining use of `MyItem`
879 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
881 T: TypeFoldable<'tcx>,
883 struct FixupFolder<'tcx> {
887 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
888 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
892 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
894 ty::Opaque(def_id, substs) => {
895 debug!("fixup_opaque_types: found type {:?}", ty);
896 // Here, we replace any inference variables that occur within
897 // the substs of an opaque type. By definition, any type occurring
898 // in the substs has a corresponding generic parameter, which is what
899 // we replace it with.
900 // This replacement is only run on the function signature, so any
901 // inference variables that we come across must be the rust of projection
902 // (there's no other way for a user to get inference variables into
903 // a function signature).
904 if ty.needs_infer() {
905 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
906 let old_param = substs[param.index as usize];
907 match old_param.unpack() {
908 GenericArgKind::Type(old_ty) => {
909 if let ty::Infer(_) = old_ty.kind {
910 // Replace inference type with a generic parameter
911 self.tcx.mk_param_from_def(param)
913 old_param.fold_with(self)
916 GenericArgKind::Const(old_const) => {
917 if let ty::ConstKind::Infer(_) = old_const.val {
918 // This should never happen - we currently do not support
919 // 'const projections', e.g.:
920 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
921 // which should be the only way for us to end up with a const inference
922 // variable after projection. If Rust ever gains support for this kind
923 // of projection, this should *probably* be changed to
924 // `self.tcx.mk_param_from_def(param)`
926 "Found infer const: `{:?}` in opaque type: {:?}",
931 old_param.fold_with(self)
934 GenericArgKind::Lifetime(old_region) => {
935 if let RegionKind::ReVar(_) = old_region {
936 self.tcx.mk_param_from_def(param)
938 old_param.fold_with(self)
943 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
944 debug!("fixup_opaque_types: new type: {:?}", new_ty);
950 _ => ty.super_fold_with(self),
955 debug!("fixup_opaque_types({:?})", val);
956 val.fold_with(&mut FixupFolder { tcx })
959 fn typeck_tables_of_const_arg<'tcx>(
961 (did, param_did): (LocalDefId, DefId),
962 ) -> &ty::TypeckTables<'tcx> {
963 let fallback = move || tcx.type_of(param_did);
964 typeck_tables_of_with_fallback(tcx, did, fallback)
967 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckTables<'tcx> {
968 if let Some(param_did) = tcx.opt_const_param_of(def_id) {
969 tcx.typeck_tables_of_const_arg((def_id, param_did))
971 let fallback = move || tcx.type_of(def_id.to_def_id());
972 typeck_tables_of_with_fallback(tcx, def_id, fallback)
976 /// Used only to get `TypeckTables` for type inference during error recovery.
977 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
978 fn diagnostic_only_typeck_tables_of<'tcx>(
981 ) -> &ty::TypeckTables<'tcx> {
982 let fallback = move || {
983 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id));
984 tcx.ty_error_with_message(span, "diagnostic only typeck table used")
986 typeck_tables_of_with_fallback(tcx, def_id, fallback)
989 fn typeck_tables_of_with_fallback<'tcx>(
992 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
993 ) -> &'tcx ty::TypeckTables<'tcx> {
994 // Closures' tables come from their outermost function,
995 // as they are part of the same "inference environment".
996 let outer_def_id = tcx.closure_base_def_id(def_id.to_def_id()).expect_local();
997 if outer_def_id != def_id {
998 return tcx.typeck_tables_of(outer_def_id);
1001 let id = tcx.hir().as_local_hir_id(def_id);
1002 let span = tcx.hir().span(id);
1004 // Figure out what primary body this item has.
1005 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
1006 span_bug!(span, "can't type-check body of {:?}", def_id);
1008 let body = tcx.hir().body(body_id);
1010 let tables = Inherited::build(tcx, def_id).enter(|inh| {
1011 let param_env = tcx.param_env(def_id);
1012 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1013 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1014 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1020 &hir::Generics::empty(),
1027 check_abi(tcx, span, fn_sig.abi());
1029 // Compute the fty from point of view of inside the fn.
1030 let fn_sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), &fn_sig);
1031 let fn_sig = inh.normalize_associated_types_in(
1038 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1040 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1043 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1044 let expected_type = body_ty
1045 .and_then(|ty| match ty.kind {
1046 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1049 .unwrap_or_else(fallback);
1050 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1051 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1053 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1054 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1059 // Gather locals in statics (because of block expressions).
1060 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1062 fcx.check_expr_coercable_to_type(&body.value, revealed_ty, None);
1064 fcx.write_ty(id, revealed_ty);
1069 // All type checking constraints were added, try to fallback unsolved variables.
1070 fcx.select_obligations_where_possible(false, |_| {});
1071 let mut fallback_has_occurred = false;
1073 // We do fallback in two passes, to try to generate
1074 // better error messages.
1075 // The first time, we do *not* replace opaque types.
1076 for ty in &fcx.unsolved_variables() {
1077 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1079 // We now see if we can make progress. This might
1080 // cause us to unify inference variables for opaque types,
1081 // since we may have unified some other type variables
1082 // during the first phase of fallback.
1083 // This means that we only replace inference variables with their underlying
1084 // opaque types as a last resort.
1086 // In code like this:
1089 // type MyType = impl Copy;
1090 // fn produce() -> MyType { true }
1091 // fn bad_produce() -> MyType { panic!() }
1094 // we want to unify the opaque inference variable in `bad_produce`
1095 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1096 // This will produce a nice error message about conflicting concrete
1097 // types for `MyType`.
1099 // If we had tried to fallback the opaque inference variable to `MyType`,
1100 // we will generate a confusing type-check error that does not explicitly
1101 // refer to opaque types.
1102 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1104 // We now run fallback again, but this time we allow it to replace
1105 // unconstrained opaque type variables, in addition to performing
1106 // other kinds of fallback.
1107 for ty in &fcx.unsolved_variables() {
1108 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1111 // See if we can make any more progress.
1112 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1114 // Even though coercion casts provide type hints, we check casts after fallback for
1115 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1118 // Closure and generator analysis may run after fallback
1119 // because they don't constrain other type variables.
1120 fcx.closure_analyze(body);
1121 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1122 fcx.resolve_generator_interiors(def_id.to_def_id());
1124 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1125 let ty = fcx.normalize_ty(span, ty);
1126 fcx.require_type_is_sized(ty, span, code);
1129 fcx.select_all_obligations_or_error();
1131 if fn_decl.is_some() {
1132 fcx.regionck_fn(id, body);
1134 fcx.regionck_expr(body);
1137 fcx.resolve_type_vars_in_body(body)
1140 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1141 // it will need to hold.
1142 assert_eq!(tables.hir_owner, id.owner);
1147 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1148 if !tcx.sess.target.target.is_abi_supported(abi) {
1153 "The ABI `{}` is not supported for the current target",
1160 struct GatherLocalsVisitor<'a, 'tcx> {
1161 fcx: &'a FnCtxt<'a, 'tcx>,
1162 parent_id: hir::HirId,
1165 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1166 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1169 // Infer the variable's type.
1170 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1171 kind: TypeVariableOriginKind::TypeInference,
1177 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1181 // Take type that the user specified.
1182 self.fcx.locals.borrow_mut().insert(nid, typ);
1189 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1190 type Map = intravisit::ErasedMap<'tcx>;
1192 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
1193 NestedVisitorMap::None
1196 // Add explicitly-declared locals.
1197 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1198 let local_ty = match local.ty {
1200 let o_ty = self.fcx.to_ty(&ty);
1202 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1203 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1212 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1214 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1215 ty.hir_id, o_ty, revealed_ty, c_ty
1217 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1219 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1223 self.assign(local.span, local.hir_id, local_ty);
1226 "local variable {:?} is assigned type {}",
1228 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&local.hir_id).unwrap().decl_ty)
1230 intravisit::walk_local(self, local);
1233 // Add pattern bindings.
1234 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1235 if let PatKind::Binding(_, _, ident, _) = p.kind {
1236 let var_ty = self.assign(p.span, p.hir_id, None);
1238 if !self.fcx.tcx.features().unsized_locals {
1239 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1243 "pattern binding {} is assigned to {} with type {:?}",
1245 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&p.hir_id).unwrap().decl_ty),
1249 intravisit::walk_pat(self, p);
1252 // Don't descend into the bodies of nested closures.
1255 _: intravisit::FnKind<'tcx>,
1256 _: &'tcx hir::FnDecl<'tcx>,
1264 /// When `check_fn` is invoked on a generator (i.e., a body that
1265 /// includes yield), it returns back some information about the yield
1267 struct GeneratorTypes<'tcx> {
1268 /// Type of generator argument / values returned by `yield`.
1269 resume_ty: Ty<'tcx>,
1271 /// Type of value that is yielded.
1274 /// Types that are captured (see `GeneratorInterior` for more).
1277 /// Indicates if the generator is movable or static (immovable).
1278 movability: hir::Movability,
1281 /// Helper used for fns and closures. Does the grungy work of checking a function
1282 /// body and returns the function context used for that purpose, since in the case of a fn item
1283 /// there is still a bit more to do.
1286 /// * inherited: other fields inherited from the enclosing fn (if any)
1287 fn check_fn<'a, 'tcx>(
1288 inherited: &'a Inherited<'a, 'tcx>,
1289 param_env: ty::ParamEnv<'tcx>,
1290 fn_sig: ty::FnSig<'tcx>,
1291 decl: &'tcx hir::FnDecl<'tcx>,
1293 body: &'tcx hir::Body<'tcx>,
1294 can_be_generator: Option<hir::Movability>,
1295 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1296 let mut fn_sig = fn_sig;
1298 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1300 // Create the function context. This is either derived from scratch or,
1301 // in the case of closures, based on the outer context.
1302 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1303 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1306 let sess = tcx.sess;
1307 let hir = tcx.hir();
1309 let declared_ret_ty = fn_sig.output();
1310 let revealed_ret_ty =
1311 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1312 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1313 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1314 fn_sig = tcx.mk_fn_sig(
1315 fn_sig.inputs().iter().cloned(),
1322 let span = body.value.span;
1324 fn_maybe_err(tcx, span, fn_sig.abi);
1326 if body.generator_kind.is_some() && can_be_generator.is_some() {
1328 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1329 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1331 // Resume type defaults to `()` if the generator has no argument.
1332 let resume_ty = fn_sig.inputs().get(0).copied().unwrap_or_else(|| tcx.mk_unit());
1334 fcx.resume_yield_tys = Some((resume_ty, yield_ty));
1337 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id).to_def_id()).expect_local();
1338 let outer_hir_id = hir.as_local_hir_id(outer_def_id);
1339 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1341 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1342 // (as it's created inside the body itself, not passed in from outside).
1343 let maybe_va_list = if fn_sig.c_variadic {
1344 let span = body.params.last().unwrap().span;
1345 let va_list_did = tcx.require_lang_item(VaListTypeLangItem, Some(span));
1346 let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span));
1348 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1353 // Add formal parameters.
1354 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1355 let inputs_fn = fn_sig.inputs().iter().copied();
1356 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1357 // Check the pattern.
1358 let ty_span = try { inputs_hir?.get(idx)?.span };
1359 fcx.check_pat_top(¶m.pat, param_ty, ty_span, false);
1361 // Check that argument is Sized.
1362 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1363 // for simple cases like `fn foo(x: Trait)`,
1364 // where we would error once on the parameter as a whole, and once on the binding `x`.
1365 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1366 fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType(ty_span));
1369 fcx.write_ty(param.hir_id, param_ty);
1372 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1374 if let ty::Dynamic(..) = declared_ret_ty.kind {
1375 // FIXME: We need to verify that the return type is `Sized` after the return expression has
1376 // been evaluated so that we have types available for all the nodes being returned, but that
1377 // requires the coerced evaluated type to be stored. Moving `check_return_expr` before this
1378 // causes unsized errors caused by the `declared_ret_ty` to point at the return expression,
1379 // while keeping the current ordering we will ignore the tail expression's type because we
1380 // don't know it yet. We can't do `check_expr_kind` while keeping `check_return_expr`
1381 // because we will trigger "unreachable expression" lints unconditionally.
1382 // Because of all of this, we perform a crude check to know whether the simplest `!Sized`
1383 // case that a newcomer might make, returning a bare trait, and in that case we populate
1384 // the tail expression's type so that the suggestion will be correct, but ignore all other
1386 fcx.check_expr(&body.value);
1387 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1388 tcx.sess.delay_span_bug(decl.output.span(), "`!Sized` return type");
1390 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1391 fcx.check_return_expr(&body.value);
1394 // We insert the deferred_generator_interiors entry after visiting the body.
1395 // This ensures that all nested generators appear before the entry of this generator.
1396 // resolve_generator_interiors relies on this property.
1397 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1399 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1400 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1402 let (resume_ty, yield_ty) = fcx.resume_yield_tys.unwrap();
1403 Some(GeneratorTypes {
1407 movability: can_be_generator.unwrap(),
1413 // Finalize the return check by taking the LUB of the return types
1414 // we saw and assigning it to the expected return type. This isn't
1415 // really expected to fail, since the coercions would have failed
1416 // earlier when trying to find a LUB.
1418 // However, the behavior around `!` is sort of complex. In the
1419 // event that the `actual_return_ty` comes back as `!`, that
1420 // indicates that the fn either does not return or "returns" only
1421 // values of type `!`. In this case, if there is an expected
1422 // return type that is *not* `!`, that should be ok. But if the
1423 // return type is being inferred, we want to "fallback" to `!`:
1425 // let x = move || panic!();
1427 // To allow for that, I am creating a type variable with diverging
1428 // fallback. This was deemed ever so slightly better than unifying
1429 // the return value with `!` because it allows for the caller to
1430 // make more assumptions about the return type (e.g., they could do
1432 // let y: Option<u32> = Some(x());
1434 // which would then cause this return type to become `u32`, not
1436 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1437 let mut actual_return_ty = coercion.complete(&fcx);
1438 if actual_return_ty.is_never() {
1439 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1440 kind: TypeVariableOriginKind::DivergingFn,
1444 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1446 // Check that the main return type implements the termination trait.
1447 if let Some(term_id) = tcx.lang_items().termination() {
1448 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1449 let main_id = hir.as_local_hir_id(def_id);
1450 if main_id == fn_id {
1451 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1452 let trait_ref = ty::TraitRef::new(term_id, substs);
1453 let return_ty_span = decl.output.span();
1454 let cause = traits::ObligationCause::new(
1457 ObligationCauseCode::MainFunctionType,
1460 inherited.register_predicate(traits::Obligation::new(
1463 trait_ref.without_const().to_predicate(tcx),
1469 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1470 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1471 if panic_impl_did == hir.local_def_id(fn_id).to_def_id() {
1472 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1473 if declared_ret_ty.kind != ty::Never {
1474 sess.span_err(decl.output.span(), "return type should be `!`");
1477 let inputs = fn_sig.inputs();
1478 let span = hir.span(fn_id);
1479 if inputs.len() == 1 {
1480 let arg_is_panic_info = match inputs[0].kind {
1481 ty::Ref(region, ty, mutbl) => match ty.kind {
1482 ty::Adt(ref adt, _) => {
1483 adt.did == panic_info_did
1484 && mutbl == hir::Mutability::Not
1485 && *region != RegionKind::ReStatic
1492 if !arg_is_panic_info {
1493 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1496 if let Node::Item(item) = hir.get(fn_id) {
1497 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1498 if !generics.params.is_empty() {
1499 sess.span_err(span, "should have no type parameters");
1504 let span = sess.source_map().guess_head_span(span);
1505 sess.span_err(span, "function should have one argument");
1508 sess.err("language item required, but not found: `panic_info`");
1513 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1514 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1515 if alloc_error_handler_did == hir.local_def_id(fn_id).to_def_id() {
1516 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1517 if declared_ret_ty.kind != ty::Never {
1518 sess.span_err(decl.output.span(), "return type should be `!`");
1521 let inputs = fn_sig.inputs();
1522 let span = hir.span(fn_id);
1523 if inputs.len() == 1 {
1524 let arg_is_alloc_layout = match inputs[0].kind {
1525 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1529 if !arg_is_alloc_layout {
1530 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1533 if let Node::Item(item) = hir.get(fn_id) {
1534 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1535 if !generics.params.is_empty() {
1538 "`#[alloc_error_handler]` function should have no type \
1545 let span = sess.source_map().guess_head_span(span);
1546 sess.span_err(span, "function should have one argument");
1549 sess.err("language item required, but not found: `alloc_layout`");
1557 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1558 let def_id = tcx.hir().local_def_id(id);
1559 let def = tcx.adt_def(def_id);
1560 def.destructor(tcx); // force the destructor to be evaluated
1561 check_representable(tcx, span, def_id);
1563 if def.repr.simd() {
1564 check_simd(tcx, span, def_id);
1567 check_transparent(tcx, span, def);
1568 check_packed(tcx, span, def);
1571 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1572 let def_id = tcx.hir().local_def_id(id);
1573 let def = tcx.adt_def(def_id);
1574 def.destructor(tcx); // force the destructor to be evaluated
1575 check_representable(tcx, span, def_id);
1576 check_transparent(tcx, span, def);
1577 check_union_fields(tcx, span, def_id);
1578 check_packed(tcx, span, def);
1581 /// When the `#![feature(untagged_unions)]` gate is active,
1582 /// check that the fields of the `union` does not contain fields that need dropping.
1583 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: LocalDefId) -> bool {
1584 let item_type = tcx.type_of(item_def_id);
1585 if let ty::Adt(def, substs) = item_type.kind {
1586 assert!(def.is_union());
1587 let fields = &def.non_enum_variant().fields;
1588 let param_env = tcx.param_env(item_def_id);
1589 for field in fields {
1590 let field_ty = field.ty(tcx, substs);
1591 // We are currently checking the type this field came from, so it must be local.
1592 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1593 if field_ty.needs_drop(tcx, param_env) {
1598 "unions may not contain fields that need dropping"
1600 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1606 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1611 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1612 /// projections that would result in "inheriting lifetimes".
1613 fn check_opaque<'tcx>(
1616 substs: SubstsRef<'tcx>,
1618 origin: &hir::OpaqueTyOrigin,
1620 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1621 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1624 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1625 /// in "inheriting lifetimes".
1626 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) {
1627 let item = tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id));
1629 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1634 struct ProhibitOpaqueVisitor<'tcx> {
1635 opaque_identity_ty: Ty<'tcx>,
1636 generics: &'tcx ty::Generics,
1637 ty: Option<Ty<'tcx>>,
1640 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1641 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1642 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1643 if t != self.opaque_identity_ty && t.super_visit_with(self) {
1650 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1651 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1652 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1653 return *index < self.generics.parent_count as u32;
1656 r.super_visit_with(self)
1659 fn visit_const(&mut self, c: &'tcx ty::Const<'tcx>) -> bool {
1660 if let ty::ConstKind::Unevaluated(..) = c.val {
1661 // FIXME(#72219) We currenctly don't detect lifetimes within substs
1662 // which would violate this check. Even though the particular substitution is not used
1663 // within the const, this should still be fixed.
1666 c.super_visit_with(self)
1670 if let ItemKind::OpaqueTy(hir::OpaqueTy {
1671 origin: hir::OpaqueTyOrigin::AsyncFn | hir::OpaqueTyOrigin::FnReturn,
1675 let mut visitor = ProhibitOpaqueVisitor {
1676 opaque_identity_ty: tcx.mk_opaque(
1678 InternalSubsts::identity_for_item(tcx, def_id.to_def_id()),
1680 generics: tcx.generics_of(def_id),
1683 let prohibit_opaque = tcx
1684 .predicates_of(def_id)
1687 .any(|(predicate, _)| predicate.visit_with(&mut visitor));
1689 "check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}, visitor={:?}",
1690 prohibit_opaque, visitor
1693 if prohibit_opaque {
1694 let is_async = match item.kind {
1695 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1696 hir::OpaqueTyOrigin::AsyncFn => true,
1699 _ => unreachable!(),
1702 let mut err = struct_span_err!(
1706 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1708 if is_async { "async fn" } else { "impl Trait" },
1711 if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(span) {
1712 if snippet == "Self" {
1713 if let Some(ty) = visitor.ty {
1714 err.span_suggestion(
1716 "consider spelling out the type instead",
1717 format!("{:?}", ty),
1718 Applicability::MaybeIncorrect,
1728 /// Given a `DefId` for an opaque type in return position, find its parent item's return
1730 fn get_owner_return_paths(
1733 ) -> Option<(hir::HirId, ReturnsVisitor<'tcx>)> {
1734 let hir_id = tcx.hir().as_local_hir_id(def_id);
1735 let id = tcx.hir().get_parent_item(hir_id);
1739 .and_then(|(hir_id, node)| node.body_id().map(|b| (hir_id, b)))
1740 .map(|(hir_id, body_id)| {
1741 let body = tcx.hir().body(body_id);
1742 let mut visitor = ReturnsVisitor::default();
1743 visitor.visit_body(body);
1748 /// Emit an error for recursive opaque types.
1750 /// If this is a return `impl Trait`, find the item's return expressions and point at them. For
1751 /// direct recursion this is enough, but for indirect recursion also point at the last intermediary
1754 /// If all the return expressions evaluate to `!`, then we explain that the error will go away
1755 /// after changing it. This can happen when a user uses `panic!()` or similar as a placeholder.
1756 fn opaque_type_cycle_error(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) {
1757 let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type");
1759 let mut label = false;
1760 if let Some((hir_id, visitor)) = get_owner_return_paths(tcx, def_id) {
1761 let tables = tcx.typeck_tables_of(tcx.hir().local_def_id(hir_id));
1765 .filter_map(|expr| tables.node_type_opt(expr.hir_id))
1766 .all(|ty| matches!(ty.kind, ty::Never))
1771 .filter(|expr| tables.node_type_opt(expr.hir_id).is_some())
1772 .map(|expr| expr.span)
1773 .collect::<Vec<Span>>();
1774 let span_len = spans.len();
1776 err.span_label(spans[0], "this returned value is of `!` type");
1778 let mut multispan: MultiSpan = spans.clone().into();
1781 .push_span_label(span, "this returned value is of `!` type".to_string());
1783 err.span_note(multispan, "these returned values have a concrete \"never\" type");
1785 err.help("this error will resolve once the item's body returns a concrete type");
1787 let mut seen = FxHashSet::default();
1789 err.span_label(span, "recursive opaque type");
1791 for (sp, ty) in visitor
1794 .filter_map(|e| tables.node_type_opt(e.hir_id).map(|t| (e.span, t)))
1795 .filter(|(_, ty)| !matches!(ty.kind, ty::Never))
1797 struct VisitTypes(Vec<DefId>);
1798 impl<'tcx> ty::fold::TypeVisitor<'tcx> for VisitTypes {
1799 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1801 ty::Opaque(def, _) => {
1805 _ => t.super_visit_with(self),
1809 let mut visitor = VisitTypes(vec![]);
1810 ty.visit_with(&mut visitor);
1811 for def_id in visitor.0 {
1812 let ty_span = tcx.def_span(def_id);
1813 if !seen.contains(&ty_span) {
1814 err.span_label(ty_span, &format!("returning this opaque type `{}`", ty));
1815 seen.insert(ty_span);
1817 err.span_label(sp, &format!("returning here with type `{}`", ty));
1823 err.span_label(span, "cannot resolve opaque type");
1828 /// Emit an error for recursive opaque types in a `let` binding.
1829 fn binding_opaque_type_cycle_error(
1833 partially_expanded_type: Ty<'tcx>,
1835 let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type");
1836 err.span_label(span, "cannot resolve opaque type");
1837 // Find the the owner that declared this `impl Trait` type.
1838 let hir_id = tcx.hir().as_local_hir_id(def_id);
1839 let mut prev_hir_id = hir_id;
1840 let mut hir_id = tcx.hir().get_parent_node(hir_id);
1841 while let Some(node) = tcx.hir().find(hir_id) {
1843 hir::Node::Local(hir::Local {
1847 source: hir::LocalSource::Normal,
1850 err.span_label(pat.span, "this binding might not have a concrete type");
1851 err.span_suggestion_verbose(
1852 ty.span.shrink_to_hi(),
1853 "set the binding to a value for a concrete type to be resolved",
1854 " = /* value */".to_string(),
1855 Applicability::HasPlaceholders,
1858 hir::Node::Local(hir::Local {
1860 source: hir::LocalSource::Normal,
1863 let hir_id = tcx.hir().as_local_hir_id(def_id);
1865 tcx.typeck_tables_of(tcx.hir().local_def_id(tcx.hir().get_parent_item(hir_id)));
1866 if let Some(ty) = tables.node_type_opt(expr.hir_id) {
1870 "this is of type `{}`, which doesn't constrain \
1871 `{}` enough to arrive to a concrete type",
1872 ty, partially_expanded_type
1879 if prev_hir_id == hir_id {
1882 prev_hir_id = hir_id;
1883 hir_id = tcx.hir().get_parent_node(hir_id);
1888 fn async_opaque_type_cycle_error(tcx: TyCtxt<'tcx>, span: Span) {
1889 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing")
1890 .span_label(span, "recursive `async fn`")
1891 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
1895 /// Checks that an opaque type does not contain cycles.
1896 fn check_opaque_for_cycles<'tcx>(
1899 substs: SubstsRef<'tcx>,
1901 origin: &hir::OpaqueTyOrigin,
1903 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id.to_def_id(), substs)
1906 hir::OpaqueTyOrigin::AsyncFn => async_opaque_type_cycle_error(tcx, span),
1907 hir::OpaqueTyOrigin::Binding => {
1908 binding_opaque_type_cycle_error(tcx, def_id, span, partially_expanded_type)
1910 _ => opaque_type_cycle_error(tcx, def_id, span),
1915 // Forbid defining intrinsics in Rust code,
1916 // as they must always be defined by the compiler.
1917 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1918 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1919 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1923 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1925 "check_item_type(it.hir_id={}, it.name={})",
1927 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id).to_def_id())
1929 let _indenter = indenter();
1931 // Consts can play a role in type-checking, so they are included here.
1932 hir::ItemKind::Static(..) => {
1933 let def_id = tcx.hir().local_def_id(it.hir_id);
1934 tcx.ensure().typeck_tables_of(def_id);
1935 maybe_check_static_with_link_section(tcx, def_id, it.span);
1937 hir::ItemKind::Const(..) => {
1938 tcx.ensure().typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1940 hir::ItemKind::Enum(ref enum_definition, _) => {
1941 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1943 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1944 hir::ItemKind::Impl { ref items, .. } => {
1945 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1946 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1947 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1948 check_impl_items_against_trait(tcx, it.span, impl_def_id, impl_trait_ref, items);
1949 let trait_def_id = impl_trait_ref.def_id;
1950 check_on_unimplemented(tcx, trait_def_id, it);
1953 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1954 let def_id = tcx.hir().local_def_id(it.hir_id);
1955 check_on_unimplemented(tcx, def_id.to_def_id(), it);
1957 for item in items.iter() {
1958 let item = tcx.hir().trait_item(item.id);
1959 if let hir::TraitItemKind::Fn(sig, _) = &item.kind {
1960 let abi = sig.header.abi;
1961 fn_maybe_err(tcx, item.ident.span, abi);
1965 hir::ItemKind::Struct(..) => {
1966 check_struct(tcx, it.hir_id, it.span);
1968 hir::ItemKind::Union(..) => {
1969 check_union(tcx, it.hir_id, it.span);
1971 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1972 let def_id = tcx.hir().local_def_id(it.hir_id);
1974 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
1975 check_opaque(tcx, def_id, substs, it.span, &origin);
1977 hir::ItemKind::TyAlias(..) => {
1978 let def_id = tcx.hir().local_def_id(it.hir_id);
1979 let pty_ty = tcx.type_of(def_id);
1980 let generics = tcx.generics_of(def_id);
1981 check_type_params_are_used(tcx, &generics, pty_ty);
1983 hir::ItemKind::ForeignMod(ref m) => {
1984 check_abi(tcx, it.span, m.abi);
1986 if m.abi == Abi::RustIntrinsic {
1987 for item in m.items {
1988 intrinsic::check_intrinsic_type(tcx, item);
1990 } else if m.abi == Abi::PlatformIntrinsic {
1991 for item in m.items {
1992 intrinsic::check_platform_intrinsic_type(tcx, item);
1995 for item in m.items {
1996 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1997 let own_counts = generics.own_counts();
1998 if generics.params.len() - own_counts.lifetimes != 0 {
1999 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
2000 (_, 0) => ("type", "types", Some("u32")),
2001 // We don't specify an example value, because we can't generate
2002 // a valid value for any type.
2003 (0, _) => ("const", "consts", None),
2004 _ => ("type or const", "types or consts", None),
2010 "foreign items may not have {} parameters",
2013 .span_label(item.span, &format!("can't have {} parameters", kinds))
2015 // FIXME: once we start storing spans for type arguments, turn this
2016 // into a suggestion.
2018 "replace the {} parameters with concrete {}{}",
2021 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
2027 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
2028 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
2033 _ => { /* nothing to do */ }
2037 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: LocalDefId, span: Span) {
2038 // Only restricted on wasm32 target for now
2039 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
2043 // If `#[link_section]` is missing, then nothing to verify
2044 let attrs = tcx.codegen_fn_attrs(id);
2045 if attrs.link_section.is_none() {
2049 // For the wasm32 target statics with `#[link_section]` are placed into custom
2050 // sections of the final output file, but this isn't link custom sections of
2051 // other executable formats. Namely we can only embed a list of bytes,
2052 // nothing with pointers to anything else or relocations. If any relocation
2053 // show up, reject them here.
2054 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
2055 // the consumer's responsibility to ensure all bytes that have been read
2056 // have defined values.
2057 match tcx.const_eval_poly(id.to_def_id()) {
2058 Ok(ConstValue::ByRef { alloc, .. }) => {
2059 if alloc.relocations().len() != 0 {
2060 let msg = "statics with a custom `#[link_section]` must be a \
2061 simple list of bytes on the wasm target with no \
2062 extra levels of indirection such as references";
2063 tcx.sess.span_err(span, msg);
2066 Ok(_) => bug!("Matching on non-ByRef static"),
2071 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
2072 let item_def_id = tcx.hir().local_def_id(item.hir_id);
2073 // an error would be reported if this fails.
2074 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id.to_def_id());
2077 fn report_forbidden_specialization(
2079 impl_item: &hir::ImplItem<'_>,
2082 let mut err = struct_span_err!(
2086 "`{}` specializes an item from a parent `impl`, but \
2087 that item is not marked `default`",
2090 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
2092 match tcx.span_of_impl(parent_impl) {
2094 err.span_label(span, "parent `impl` is here");
2096 "to specialize, `{}` in the parent `impl` must be marked `default`",
2101 err.note(&format!("parent implementation is in crate `{}`", cname));
2108 fn check_specialization_validity<'tcx>(
2110 trait_def: &ty::TraitDef,
2111 trait_item: &ty::AssocItem,
2113 impl_item: &hir::ImplItem<'_>,
2115 let kind = match impl_item.kind {
2116 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
2117 hir::ImplItemKind::Fn(..) => ty::AssocKind::Fn,
2118 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
2121 let ancestors = match trait_def.ancestors(tcx, impl_id) {
2122 Ok(ancestors) => ancestors,
2125 let mut ancestor_impls = ancestors
2127 .filter_map(|parent| {
2128 if parent.is_from_trait() {
2131 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
2136 if ancestor_impls.peek().is_none() {
2137 // No parent, nothing to specialize.
2141 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
2143 // Parent impl exists, and contains the parent item we're trying to specialize, but
2144 // doesn't mark it `default`.
2145 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
2146 Some(Err(parent_impl.def_id()))
2149 // Parent impl contains item and makes it specializable.
2150 Some(_) => Some(Ok(())),
2152 // Parent impl doesn't mention the item. This means it's inherited from the
2153 // grandparent. In that case, if parent is a `default impl`, inherited items use the
2154 // "defaultness" from the grandparent, else they are final.
2156 if tcx.impl_defaultness(parent_impl.def_id()).is_default() {
2159 Some(Err(parent_impl.def_id()))
2165 // If `opt_result` is `None`, we have only encountered `default impl`s that don't contain the
2166 // item. This is allowed, the item isn't actually getting specialized here.
2167 let result = opt_result.unwrap_or(Ok(()));
2169 if let Err(parent_impl) = result {
2170 report_forbidden_specialization(tcx, impl_item, parent_impl);
2174 fn check_impl_items_against_trait<'tcx>(
2176 full_impl_span: Span,
2177 impl_id: LocalDefId,
2178 impl_trait_ref: ty::TraitRef<'tcx>,
2179 impl_item_refs: &[hir::ImplItemRef<'_>],
2181 let impl_span = tcx.sess.source_map().guess_head_span(full_impl_span);
2183 // If the trait reference itself is erroneous (so the compilation is going
2184 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
2185 // isn't populated for such impls.
2186 if impl_trait_ref.references_error() {
2190 // Negative impls are not expected to have any items
2191 match tcx.impl_polarity(impl_id) {
2192 ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
2193 ty::ImplPolarity::Negative => {
2194 if let [first_item_ref, ..] = impl_item_refs {
2195 let first_item_span = tcx.hir().impl_item(first_item_ref.id).span;
2200 "negative impls cannot have any items"
2208 // Locate trait definition and items
2209 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
2211 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
2213 // Check existing impl methods to see if they are both present in trait
2214 // and compatible with trait signature
2215 for impl_item in impl_items() {
2216 let namespace = impl_item.kind.namespace();
2217 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
2218 let ty_trait_item = tcx
2219 .associated_items(impl_trait_ref.def_id)
2220 .find_by_name_and_namespace(tcx, ty_impl_item.ident, namespace, impl_trait_ref.def_id)
2222 // Not compatible, but needed for the error message
2223 tcx.associated_items(impl_trait_ref.def_id)
2224 .filter_by_name(tcx, ty_impl_item.ident, impl_trait_ref.def_id)
2228 // Check that impl definition matches trait definition
2229 if let Some(ty_trait_item) = ty_trait_item {
2230 match impl_item.kind {
2231 hir::ImplItemKind::Const(..) => {
2232 // Find associated const definition.
2233 if ty_trait_item.kind == ty::AssocKind::Const {
2242 let mut err = struct_span_err!(
2246 "item `{}` is an associated const, \
2247 which doesn't match its trait `{}`",
2249 impl_trait_ref.print_only_trait_path()
2251 err.span_label(impl_item.span, "does not match trait");
2252 // We can only get the spans from local trait definition
2253 // Same for E0324 and E0325
2254 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2255 err.span_label(trait_span, "item in trait");
2260 hir::ImplItemKind::Fn(..) => {
2261 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2262 if ty_trait_item.kind == ty::AssocKind::Fn {
2263 compare_impl_method(
2272 let mut err = struct_span_err!(
2276 "item `{}` is an associated method, \
2277 which doesn't match its trait `{}`",
2279 impl_trait_ref.print_only_trait_path()
2281 err.span_label(impl_item.span, "does not match trait");
2282 if let Some(trait_span) = opt_trait_span {
2283 err.span_label(trait_span, "item in trait");
2288 hir::ImplItemKind::TyAlias(_) => {
2289 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2290 if ty_trait_item.kind == ty::AssocKind::Type {
2300 let mut err = struct_span_err!(
2304 "item `{}` is an associated type, \
2305 which doesn't match its trait `{}`",
2307 impl_trait_ref.print_only_trait_path()
2309 err.span_label(impl_item.span, "does not match trait");
2310 if let Some(trait_span) = opt_trait_span {
2311 err.span_label(trait_span, "item in trait");
2318 check_specialization_validity(
2322 impl_id.to_def_id(),
2328 // Check for missing items from trait
2329 let mut missing_items = Vec::new();
2330 if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id.to_def_id()) {
2331 for trait_item in tcx.associated_items(impl_trait_ref.def_id).in_definition_order() {
2332 let is_implemented = ancestors
2333 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2334 .map(|node_item| !node_item.defining_node.is_from_trait())
2337 if !is_implemented && tcx.impl_defaultness(impl_id).is_final() {
2338 if !trait_item.defaultness.has_value() {
2339 missing_items.push(*trait_item);
2345 if !missing_items.is_empty() {
2346 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2350 fn missing_items_err(
2353 missing_items: &[ty::AssocItem],
2354 full_impl_span: Span,
2356 let missing_items_msg = missing_items
2358 .map(|trait_item| trait_item.ident.to_string())
2359 .collect::<Vec<_>>()
2362 let mut err = struct_span_err!(
2366 "not all trait items implemented, missing: `{}`",
2369 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2371 // `Span` before impl block closing brace.
2372 let hi = full_impl_span.hi() - BytePos(1);
2373 // Point at the place right before the closing brace of the relevant `impl` to suggest
2374 // adding the associated item at the end of its body.
2375 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2376 // Obtain the level of indentation ending in `sugg_sp`.
2377 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2378 // Make the whitespace that will make the suggestion have the right indentation.
2379 let padding: String = (0..indentation).map(|_| " ").collect();
2381 for trait_item in missing_items {
2382 let snippet = suggestion_signature(&trait_item, tcx);
2383 let code = format!("{}{}\n{}", padding, snippet, padding);
2384 let msg = format!("implement the missing item: `{}`", snippet);
2385 let appl = Applicability::HasPlaceholders;
2386 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2387 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2388 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2390 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2396 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
2397 fn bounds_from_generic_predicates(
2399 predicates: ty::GenericPredicates<'_>,
2400 ) -> (String, String) {
2401 let mut types: FxHashMap<Ty<'_>, Vec<DefId>> = FxHashMap::default();
2402 let mut projections = vec![];
2403 for (predicate, _) in predicates.predicates {
2404 debug!("predicate {:?}", predicate);
2405 match predicate.kind() {
2406 ty::PredicateKind::Trait(trait_predicate, _) => {
2407 let entry = types.entry(trait_predicate.skip_binder().self_ty()).or_default();
2408 let def_id = trait_predicate.skip_binder().def_id();
2409 if Some(def_id) != tcx.lang_items().sized_trait() {
2410 // Type params are `Sized` by default, do not add that restriction to the list
2411 // if it is a positive requirement.
2412 entry.push(trait_predicate.skip_binder().def_id());
2415 ty::PredicateKind::Projection(projection_pred) => {
2416 projections.push(projection_pred);
2421 let generics = if types.is_empty() {
2428 .filter_map(|t| match t.kind {
2429 ty::Param(_) => Some(t.to_string()),
2430 // Avoid suggesting the following:
2431 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
2434 .collect::<Vec<_>>()
2438 let mut where_clauses = vec![];
2439 for (ty, bounds) in types {
2440 for bound in &bounds {
2441 where_clauses.push(format!("{}: {}", ty, tcx.def_path_str(*bound)));
2444 for projection in &projections {
2445 let p = projection.skip_binder();
2446 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
2447 // insert the associated types where they correspond, but for now let's be "lazy" and
2448 // propose this instead of the following valid resugaring:
2449 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
2450 where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.item_def_id), p.ty));
2452 let where_clauses = if where_clauses.is_empty() {
2455 format!(" where {}", where_clauses.join(", "))
2457 (generics, where_clauses)
2460 /// Return placeholder code for the given function.
2461 fn fn_sig_suggestion(
2465 predicates: ty::GenericPredicates<'_>,
2466 assoc: &ty::AssocItem,
2473 Some(match ty.kind {
2474 ty::Param(_) if assoc.fn_has_self_parameter && i == 0 => "self".to_string(),
2475 ty::Ref(reg, ref_ty, mutability) if i == 0 => {
2476 let reg = match &format!("{}", reg)[..] {
2477 "'_" | "" => String::new(),
2478 reg => format!("{} ", reg),
2480 if assoc.fn_has_self_parameter {
2482 ty::Param(param) if param.name == kw::SelfUpper => {
2483 format!("&{}{}self", reg, mutability.prefix_str())
2486 _ => format!("self: {}", ty),
2489 format!("_: {:?}", ty)
2493 if assoc.fn_has_self_parameter && i == 0 {
2494 format!("self: {:?}", ty)
2496 format!("_: {:?}", ty)
2501 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2502 .filter_map(|arg| arg)
2503 .collect::<Vec<String>>()
2505 let output = sig.output();
2506 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2508 let unsafety = sig.unsafety.prefix_str();
2509 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
2511 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2512 // not be present in the `fn` definition, not will we account for renamed
2513 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2514 // fill in a significant portion of the missing code, and other subsequent
2515 // suggestions can help the user fix the code.
2517 "{}fn {}{}({}){}{} {{ todo!() }}",
2518 unsafety, ident, generics, args, output, where_clauses
2522 /// Return placeholder code for the given associated item.
2523 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2524 /// structured suggestion.
2525 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2527 ty::AssocKind::Fn => {
2528 // We skip the binder here because the binder would deanonymize all
2529 // late-bound regions, and we don't want method signatures to show up
2530 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2531 // regions just fine, showing `fn(&MyType)`.
2534 tcx.fn_sig(assoc.def_id).skip_binder(),
2536 tcx.predicates_of(assoc.def_id),
2540 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2541 ty::AssocKind::Const => {
2542 let ty = tcx.type_of(assoc.def_id);
2543 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2544 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2549 /// Checks whether a type can be represented in memory. In particular, it
2550 /// identifies types that contain themselves without indirection through a
2551 /// pointer, which would mean their size is unbounded.
2552 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: LocalDefId) -> bool {
2553 let rty = tcx.type_of(item_def_id);
2555 // Check that it is possible to represent this type. This call identifies
2556 // (1) types that contain themselves and (2) types that contain a different
2557 // recursive type. It is only necessary to throw an error on those that
2558 // contain themselves. For case 2, there must be an inner type that will be
2559 // caught by case 1.
2560 match rty.is_representable(tcx, sp) {
2561 Representability::SelfRecursive(spans) => {
2562 recursive_type_with_infinite_size_error(tcx, item_def_id.to_def_id(), spans);
2565 Representability::Representable | Representability::ContainsRecursive => (),
2570 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
2571 let t = tcx.type_of(def_id);
2572 if let ty::Adt(def, substs) = t.kind {
2573 if def.is_struct() {
2574 let fields = &def.non_enum_variant().fields;
2575 if fields.is_empty() {
2576 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2579 let e = fields[0].ty(tcx, substs);
2580 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2581 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2582 .span_label(sp, "SIMD elements must have the same type")
2587 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2588 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2594 "SIMD vector element type should be machine type"
2604 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: &ty::AdtDef) {
2605 let repr = def.repr;
2607 for attr in tcx.get_attrs(def.did).iter() {
2608 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2609 if let attr::ReprPacked(pack) = r {
2610 if let Some(repr_pack) = repr.pack {
2611 if pack as u64 != repr_pack.bytes() {
2616 "type has conflicting packed representation hints"
2624 if repr.align.is_some() {
2629 "type has conflicting packed and align representation hints"
2633 if let Some(def_spans) = check_packed_inner(tcx, def.did, &mut vec![]) {
2634 let mut err = struct_span_err!(
2638 "packed type cannot transitively contain a `#[repr(align)]` type"
2642 tcx.def_span(def_spans[0].0),
2644 "`{}` has a `#[repr(align)]` attribute",
2645 tcx.item_name(def_spans[0].0)
2649 if def_spans.len() > 2 {
2650 let mut first = true;
2651 for (adt_def, span) in def_spans.iter().skip(1).rev() {
2652 let ident = tcx.item_name(*adt_def);
2657 "`{}` contains a field of type `{}`",
2658 tcx.type_of(def.did),
2662 format!("...which contains a field of type `{}`", ident)
2675 fn check_packed_inner(
2678 stack: &mut Vec<DefId>,
2679 ) -> Option<Vec<(DefId, Span)>> {
2680 if let ty::Adt(def, substs) = tcx.type_of(def_id).kind {
2681 if def.is_struct() || def.is_union() {
2682 if def.repr.align.is_some() {
2683 return Some(vec![(def.did, DUMMY_SP)]);
2687 for field in &def.non_enum_variant().fields {
2688 if let ty::Adt(def, _) = field.ty(tcx, substs).kind {
2689 if !stack.contains(&def.did) {
2690 if let Some(mut defs) = check_packed_inner(tcx, def.did, stack) {
2691 defs.push((def.did, field.ident.span));
2704 /// Emit an error when encountering more or less than one variant in a transparent enum.
2705 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2706 let variant_spans: Vec<_> = adt
2709 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2711 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2712 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2713 err.span_label(sp, &msg);
2714 if let [start @ .., end] = &*variant_spans {
2715 for variant_span in start {
2716 err.span_label(*variant_span, "");
2718 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2723 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2725 fn bad_non_zero_sized_fields<'tcx>(
2727 adt: &'tcx ty::AdtDef,
2729 field_spans: impl Iterator<Item = Span>,
2732 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2733 let mut err = struct_span_err!(
2737 "{}transparent {} {}",
2738 if adt.is_enum() { "the variant of a " } else { "" },
2742 err.span_label(sp, &msg);
2743 for sp in field_spans {
2744 err.span_label(sp, "this field is non-zero-sized");
2749 fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, adt: &'tcx ty::AdtDef) {
2750 if !adt.repr.transparent() {
2753 let sp = tcx.sess.source_map().guess_head_span(sp);
2755 if adt.is_union() && !tcx.features().transparent_unions {
2757 &tcx.sess.parse_sess,
2758 sym::transparent_unions,
2760 "transparent unions are unstable",
2765 if adt.variants.len() != 1 {
2766 bad_variant_count(tcx, adt, sp, adt.did);
2767 if adt.variants.is_empty() {
2768 // Don't bother checking the fields. No variants (and thus no fields) exist.
2773 // For each field, figure out if it's known to be a ZST and align(1)
2774 let field_infos = adt.all_fields().map(|field| {
2775 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2776 let param_env = tcx.param_env(field.did);
2777 let layout = tcx.layout_of(param_env.and(ty));
2778 // We are currently checking the type this field came from, so it must be local
2779 let span = tcx.hir().span_if_local(field.did).unwrap();
2780 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2781 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2785 let non_zst_fields =
2786 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2787 let non_zst_count = non_zst_fields.clone().count();
2788 if non_zst_count != 1 {
2789 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2791 for (span, zst, align1) in field_infos {
2797 "zero-sized field in transparent {} has alignment larger than 1",
2800 .span_label(span, "has alignment larger than 1")
2806 #[allow(trivial_numeric_casts)]
2807 pub fn check_enum<'tcx>(
2810 vs: &'tcx [hir::Variant<'tcx>],
2813 let def_id = tcx.hir().local_def_id(id);
2814 let def = tcx.adt_def(def_id);
2815 def.destructor(tcx); // force the destructor to be evaluated
2818 let attributes = tcx.get_attrs(def_id.to_def_id());
2819 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2824 "unsupported representation for zero-variant enum"
2826 .span_label(sp, "zero-variant enum")
2831 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2832 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2833 if !tcx.features().repr128 {
2835 &tcx.sess.parse_sess,
2838 "repr with 128-bit type is unstable",
2845 if let Some(ref e) = v.disr_expr {
2846 tcx.ensure().typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2850 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2851 let is_unit = |var: &hir::Variant<'_>| match var.data {
2852 hir::VariantData::Unit(..) => true,
2856 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2857 let has_non_units = vs.iter().any(|var| !is_unit(var));
2858 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2859 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2861 if disr_non_unit || (disr_units && has_non_units) {
2863 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2868 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2869 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2870 // Check for duplicate discriminant values
2871 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2872 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2873 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did.expect_local());
2874 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2875 let i_span = match variant_i.disr_expr {
2876 Some(ref expr) => tcx.hir().span(expr.hir_id),
2877 None => tcx.hir().span(variant_i_hir_id),
2879 let span = match v.disr_expr {
2880 Some(ref expr) => tcx.hir().span(expr.hir_id),
2887 "discriminant value `{}` already exists",
2890 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2891 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2894 disr_vals.push(discr);
2897 check_representable(tcx, sp, def_id);
2898 check_transparent(tcx, sp, def);
2901 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
2906 "expected unit struct, unit variant or constant, found {}{}",
2908 tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`", s)),
2913 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2914 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2918 fn item_def_id(&self) -> Option<DefId> {
2922 fn default_constness_for_trait_bounds(&self) -> hir::Constness {
2923 // FIXME: refactor this into a method
2924 let node = self.tcx.hir().get(self.body_id);
2925 if let Some(fn_like) = FnLikeNode::from_node(node) {
2928 hir::Constness::NotConst
2932 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2934 let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local());
2935 let item_id = tcx.hir().ty_param_owner(hir_id);
2936 let item_def_id = tcx.hir().local_def_id(item_id);
2937 let generics = tcx.generics_of(item_def_id);
2938 let index = generics.param_def_id_to_index[&def_id];
2939 ty::GenericPredicates {
2941 predicates: tcx.arena.alloc_from_iter(
2942 self.param_env.caller_bounds().iter().filter_map(|predicate| {
2943 match predicate.kind() {
2944 ty::PredicateKind::Trait(ref data, _)
2945 if data.skip_binder().self_ty().is_param(index) =>
2947 // HACK(eddyb) should get the original `Span`.
2948 let span = tcx.def_span(def_id);
2949 Some((predicate, span))
2958 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2960 Some(def) => infer::EarlyBoundRegion(span, def.name),
2961 None => infer::MiscVariable(span),
2963 Some(self.next_region_var(v))
2966 fn allow_ty_infer(&self) -> bool {
2970 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2971 if let Some(param) = param {
2972 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2977 self.next_ty_var(TypeVariableOrigin {
2978 kind: TypeVariableOriginKind::TypeInference,
2987 param: Option<&ty::GenericParamDef>,
2989 ) -> &'tcx Const<'tcx> {
2990 if let Some(param) = param {
2991 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2996 self.next_const_var(
2998 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
3003 fn projected_ty_from_poly_trait_ref(
3007 item_segment: &hir::PathSegment<'_>,
3008 poly_trait_ref: ty::PolyTraitRef<'tcx>,
3010 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
3012 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
3016 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
3025 self.tcx().mk_projection(item_def_id, item_substs)
3028 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
3029 if ty.has_escaping_bound_vars() {
3030 ty // FIXME: normalization and escaping regions
3032 self.normalize_associated_types_in(span, &ty)
3036 fn set_tainted_by_errors(&self) {
3037 self.infcx.set_tainted_by_errors()
3040 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
3041 self.write_ty(hir_id, ty)
3045 /// Controls whether the arguments are tupled. This is used for the call
3048 /// Tupling means that all call-side arguments are packed into a tuple and
3049 /// passed as a single parameter. For example, if tupling is enabled, this
3052 /// fn f(x: (isize, isize))
3054 /// Can be called as:
3061 #[derive(Clone, Eq, PartialEq)]
3062 enum TupleArgumentsFlag {
3067 /// Controls how we perform fallback for unconstrained
3070 /// Do not fallback type variables to opaque types.
3072 /// Perform all possible kinds of fallback, including
3073 /// turning type variables to opaque types.
3077 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
3079 inh: &'a Inherited<'a, 'tcx>,
3080 param_env: ty::ParamEnv<'tcx>,
3081 body_id: hir::HirId,
3082 ) -> FnCtxt<'a, 'tcx> {
3086 err_count_on_creation: inh.tcx.sess.err_count(),
3088 ret_coercion_span: RefCell::new(None),
3089 resume_yield_tys: None,
3090 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
3091 diverges: Cell::new(Diverges::Maybe),
3092 has_errors: Cell::new(false),
3093 enclosing_breakables: RefCell::new(EnclosingBreakables {
3095 by_id: Default::default(),
3101 pub fn sess(&self) -> &Session {
3105 pub fn errors_reported_since_creation(&self) -> bool {
3106 self.tcx.sess.err_count() > self.err_count_on_creation
3109 /// Produces warning on the given node, if the current point in the
3110 /// function is unreachable, and there hasn't been another warning.
3111 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
3112 // FIXME: Combine these two 'if' expressions into one once
3113 // let chains are implemented
3114 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
3115 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
3116 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
3117 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
3118 if !span.is_desugaring(DesugaringKind::CondTemporary)
3119 && !span.is_desugaring(DesugaringKind::Async)
3120 && !orig_span.is_desugaring(DesugaringKind::Await)
3122 self.diverges.set(Diverges::WarnedAlways);
3124 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
3126 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, |lint| {
3127 let msg = format!("unreachable {}", kind);
3129 .span_label(span, &msg)
3133 .unwrap_or("any code following this expression is unreachable"),
3141 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
3142 ObligationCause::new(span, self.body_id, code)
3145 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
3146 self.cause(span, ObligationCauseCode::MiscObligation)
3149 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
3150 /// version (resolve_vars_if_possible), this version will
3151 /// also select obligations if it seems useful, in an effort
3152 /// to get more type information.
3153 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
3154 debug!("resolve_vars_with_obligations(ty={:?})", ty);
3156 // No Infer()? Nothing needs doing.
3157 if !ty.has_infer_types_or_consts() {
3158 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3162 // If `ty` is a type variable, see whether we already know what it is.
3163 ty = self.resolve_vars_if_possible(&ty);
3164 if !ty.has_infer_types_or_consts() {
3165 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3169 // If not, try resolving pending obligations as much as
3170 // possible. This can help substantially when there are
3171 // indirect dependencies that don't seem worth tracking
3173 self.select_obligations_where_possible(false, |_| {});
3174 ty = self.resolve_vars_if_possible(&ty);
3176 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3180 fn record_deferred_call_resolution(
3182 closure_def_id: DefId,
3183 r: DeferredCallResolution<'tcx>,
3185 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3186 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
3189 fn remove_deferred_call_resolutions(
3191 closure_def_id: DefId,
3192 ) -> Vec<DeferredCallResolution<'tcx>> {
3193 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3194 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
3197 pub fn tag(&self) -> String {
3198 format!("{:p}", self)
3201 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
3202 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
3203 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
3208 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
3210 "write_ty({:?}, {:?}) in fcx {}",
3212 self.resolve_vars_if_possible(&ty),
3215 self.tables.borrow_mut().node_types_mut().insert(id, ty);
3217 if ty.references_error() {
3218 self.has_errors.set(true);
3219 self.set_tainted_by_errors();
3223 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
3224 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
3227 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
3228 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
3231 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
3232 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
3233 self.write_resolution(hir_id, Ok((DefKind::AssocFn, method.def_id)));
3234 self.write_substs(hir_id, method.substs);
3236 // When the method is confirmed, the `method.substs` includes
3237 // parameters from not just the method, but also the impl of
3238 // the method -- in particular, the `Self` type will be fully
3239 // resolved. However, those are not something that the "user
3240 // specified" -- i.e., those types come from the inferred type
3241 // of the receiver, not something the user wrote. So when we
3242 // create the user-substs, we want to replace those earlier
3243 // types with just the types that the user actually wrote --
3244 // that is, those that appear on the *method itself*.
3246 // As an example, if the user wrote something like
3247 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
3248 // type of `foo` (possibly adjusted), but we don't want to
3249 // include that. We want just the `[_, u32]` part.
3250 if !method.substs.is_noop() {
3251 let method_generics = self.tcx.generics_of(method.def_id);
3252 if !method_generics.params.is_empty() {
3253 let user_type_annotation = self.infcx.probe(|_| {
3254 let user_substs = UserSubsts {
3255 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
3256 let i = param.index as usize;
3257 if i < method_generics.parent_count {
3258 self.infcx.var_for_def(DUMMY_SP, param)
3263 user_self_ty: None, // not relevant here
3266 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3272 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
3273 self.write_user_type_annotation(hir_id, user_type_annotation);
3278 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
3279 if !substs.is_noop() {
3280 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
3282 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
3286 /// Given the substs that we just converted from the HIR, try to
3287 /// canonicalize them and store them as user-given substitutions
3288 /// (i.e., substitutions that must be respected by the NLL check).
3290 /// This should be invoked **before any unifications have
3291 /// occurred**, so that annotations like `Vec<_>` are preserved
3293 pub fn write_user_type_annotation_from_substs(
3297 substs: SubstsRef<'tcx>,
3298 user_self_ty: Option<UserSelfTy<'tcx>>,
3301 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
3302 user_self_ty={:?} in fcx {}",
3310 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
3311 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3313 UserSubsts { substs, user_self_ty },
3315 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
3316 self.write_user_type_annotation(hir_id, canonicalized);
3320 pub fn write_user_type_annotation(
3323 canonical_user_type_annotation: CanonicalUserType<'tcx>,
3326 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
3328 canonical_user_type_annotation,
3332 if !canonical_user_type_annotation.is_identity() {
3335 .user_provided_types_mut()
3336 .insert(hir_id, canonical_user_type_annotation);
3338 debug!("write_user_type_annotation: skipping identity substs");
3342 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
3343 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
3349 let autoborrow_mut = adj.iter().any(|adj| {
3350 matches!(adj, &Adjustment {
3351 kind: Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })),
3356 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
3357 Entry::Vacant(entry) => {
3360 Entry::Occupied(mut entry) => {
3361 debug!(" - composing on top of {:?}", entry.get());
3362 match (&entry.get()[..], &adj[..]) {
3363 // Applying any adjustment on top of a NeverToAny
3364 // is a valid NeverToAny adjustment, because it can't
3366 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3368 Adjustment { kind: Adjust::Deref(_), .. },
3369 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3371 Adjustment { kind: Adjust::Deref(_), .. },
3372 .. // Any following adjustments are allowed.
3374 // A reborrow has no effect before a dereference.
3376 // FIXME: currently we never try to compose autoderefs
3377 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3379 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3380 expr, entry.get(), adj)
3382 *entry.get_mut() = adj;
3386 // If there is an mutable auto-borrow, it is equivalent to `&mut <expr>`.
3387 // In this case implicit use of `Deref` and `Index` within `<expr>` should
3388 // instead be `DerefMut` and `IndexMut`, so fix those up.
3390 self.convert_place_derefs_to_mutable(expr);
3394 /// Basically whenever we are converting from a type scheme into
3395 /// the fn body space, we always want to normalize associated
3396 /// types as well. This function combines the two.
3397 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3399 T: TypeFoldable<'tcx>,
3401 let value = value.subst(self.tcx, substs);
3402 let result = self.normalize_associated_types_in(span, &value);
3403 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3407 /// As `instantiate_type_scheme`, but for the bounds found in a
3408 /// generic type scheme.
3409 fn instantiate_bounds(
3413 substs: SubstsRef<'tcx>,
3414 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3415 let bounds = self.tcx.predicates_of(def_id);
3416 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3417 let result = bounds.instantiate(self.tcx, substs);
3418 let result = self.normalize_associated_types_in(span, &result);
3420 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3421 bounds, substs, result, spans,
3426 /// Replaces the opaque types from the given value with type variables,
3427 /// and records the `OpaqueTypeMap` for later use during writeback. See
3428 /// `InferCtxt::instantiate_opaque_types` for more details.
3429 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3431 parent_id: hir::HirId,
3435 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3437 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3438 parent_def_id, value
3441 let (value, opaque_type_map) =
3442 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3450 let mut opaque_types = self.opaque_types.borrow_mut();
3451 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3452 for (ty, decl) in opaque_type_map {
3453 let _ = opaque_types.insert(ty, decl);
3454 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3460 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3462 T: TypeFoldable<'tcx>,
3464 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3467 fn normalize_associated_types_in_as_infer_ok<T>(
3471 ) -> InferOk<'tcx, T>
3473 T: TypeFoldable<'tcx>,
3475 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3478 pub fn require_type_meets(
3482 code: traits::ObligationCauseCode<'tcx>,
3485 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3488 pub fn require_type_is_sized(
3492 code: traits::ObligationCauseCode<'tcx>,
3494 if !ty.references_error() {
3495 let lang_item = self.tcx.require_lang_item(SizedTraitLangItem, None);
3496 self.require_type_meets(ty, span, code, lang_item);
3500 pub fn require_type_is_sized_deferred(
3504 code: traits::ObligationCauseCode<'tcx>,
3506 if !ty.references_error() {
3507 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3511 pub fn register_bound(
3515 cause: traits::ObligationCause<'tcx>,
3517 if !ty.references_error() {
3518 self.fulfillment_cx.borrow_mut().register_bound(
3528 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3529 let t = AstConv::ast_ty_to_ty(self, ast_t);
3530 self.register_wf_obligation(t.into(), ast_t.span, traits::MiscObligation);
3534 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3535 let ty = self.to_ty(ast_ty);
3536 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3538 if Self::can_contain_user_lifetime_bounds(ty) {
3539 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3540 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3541 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3547 pub fn to_const(&self, ast_c: &hir::AnonConst) -> &'tcx ty::Const<'tcx> {
3548 let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id);
3549 let c = ty::Const::from_anon_const(self.tcx, const_def_id);
3550 self.register_wf_obligation(
3552 self.tcx.hir().span(ast_c.hir_id),
3553 ObligationCauseCode::MiscObligation,
3558 pub fn const_arg_to_const(
3560 ast_c: &hir::AnonConst,
3561 param_def_id: DefId,
3562 ) -> &'tcx ty::Const<'tcx> {
3563 let const_def = ty::WithOptConstParam {
3564 did: self.tcx.hir().local_def_id(ast_c.hir_id),
3565 const_param_did: Some(param_def_id),
3567 let c = ty::Const::from_opt_const_arg_anon_const(self.tcx, const_def);
3568 self.register_wf_obligation(
3570 self.tcx.hir().span(ast_c.hir_id),
3571 ObligationCauseCode::MiscObligation,
3576 // If the type given by the user has free regions, save it for later, since
3577 // NLL would like to enforce those. Also pass in types that involve
3578 // projections, since those can resolve to `'static` bounds (modulo #54940,
3579 // which hopefully will be fixed by the time you see this comment, dear
3580 // reader, although I have my doubts). Also pass in types with inference
3581 // types, because they may be repeated. Other sorts of things are already
3582 // sufficiently enforced with erased regions. =)
3583 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3585 T: TypeFoldable<'tcx>,
3587 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3590 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3591 match self.tables.borrow().node_types().get(id) {
3593 None if self.is_tainted_by_errors() => self.tcx.ty_error(),
3596 "no type for node {}: {} in fcx {}",
3598 self.tcx.hir().node_to_string(id),
3605 /// Registers an obligation for checking later, during regionck, that `arg` is well-formed.
3606 pub fn register_wf_obligation(
3608 arg: subst::GenericArg<'tcx>,
3610 code: traits::ObligationCauseCode<'tcx>,
3612 // WF obligations never themselves fail, so no real need to give a detailed cause:
3613 let cause = traits::ObligationCause::new(span, self.body_id, code);
3614 self.register_predicate(traits::Obligation::new(
3617 ty::PredicateKind::WellFormed(arg).to_predicate(self.tcx),
3621 /// Registers obligations that all `substs` are well-formed.
3622 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3623 for arg in substs.iter().filter(|arg| {
3624 matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
3626 self.register_wf_obligation(arg, expr.span, traits::MiscObligation);
3630 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3631 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3632 /// trait/region obligations.
3634 /// For example, if there is a function:
3637 /// fn foo<'a,T:'a>(...)
3640 /// and a reference:
3646 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3647 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3648 pub fn add_obligations_for_parameters(
3650 cause: traits::ObligationCause<'tcx>,
3651 predicates: ty::InstantiatedPredicates<'tcx>,
3653 assert!(!predicates.has_escaping_bound_vars());
3655 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3657 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3658 self.register_predicate(obligation);
3662 // FIXME(arielb1): use this instead of field.ty everywhere
3663 // Only for fields! Returns <none> for methods>
3664 // Indifferent to privacy flags
3668 field: &'tcx ty::FieldDef,
3669 substs: SubstsRef<'tcx>,
3671 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3674 fn check_casts(&self) {
3675 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3676 for cast in deferred_cast_checks.drain(..) {
3681 fn resolve_generator_interiors(&self, def_id: DefId) {
3682 let mut generators = self.deferred_generator_interiors.borrow_mut();
3683 for (body_id, interior, kind) in generators.drain(..) {
3684 self.select_obligations_where_possible(false, |_| {});
3685 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3689 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3691 // - Unconstrained ints are replaced with `i32`.
3693 // - Unconstrained floats are replaced with with `f64`.
3695 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3696 // is enabled. Otherwise, they are replaced with `()`.
3698 // Fallback becomes very dubious if we have encountered type-checking errors.
3699 // In that case, fallback to Error.
3700 // The return value indicates whether fallback has occurred.
3701 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3702 use rustc_middle::ty::error::UnconstrainedNumeric::Neither;
3703 use rustc_middle::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3705 assert!(ty.is_ty_infer());
3706 let fallback = match self.type_is_unconstrained_numeric(ty) {
3707 _ if self.is_tainted_by_errors() => self.tcx().ty_error(),
3708 UnconstrainedInt => self.tcx.types.i32,
3709 UnconstrainedFloat => self.tcx.types.f64,
3710 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3712 // This type variable was created from the instantiation of an opaque
3713 // type. The fact that we're attempting to perform fallback for it
3714 // means that the function neither constrained it to a concrete
3715 // type, nor to the opaque type itself.
3717 // For example, in this code:
3720 // type MyType = impl Copy;
3721 // fn defining_use() -> MyType { true }
3722 // fn other_use() -> MyType { defining_use() }
3725 // `defining_use` will constrain the instantiated inference
3726 // variable to `bool`, while `other_use` will constrain
3727 // the instantiated inference variable to `MyType`.
3729 // When we process opaque types during writeback, we
3730 // will handle cases like `other_use`, and not count
3731 // them as defining usages
3733 // However, we also need to handle cases like this:
3736 // pub type Foo = impl Copy;
3737 // fn produce() -> Option<Foo> {
3742 // In the above snippet, the inference variable created by
3743 // instantiating `Option<Foo>` will be completely unconstrained.
3744 // We treat this as a non-defining use by making the inference
3745 // variable fall back to the opaque type itself.
3746 if let FallbackMode::All = mode {
3747 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3749 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3761 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3762 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3766 fn select_all_obligations_or_error(&self) {
3767 debug!("select_all_obligations_or_error");
3768 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3769 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3773 /// Select as many obligations as we can at present.
3774 fn select_obligations_where_possible(
3776 fallback_has_occurred: bool,
3777 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3779 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3780 if let Err(mut errors) = result {
3781 mutate_fullfillment_errors(&mut errors);
3782 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3786 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3787 /// returns a type of `&T`, but the actual type we assign to the
3788 /// *expression* is `T`. So this function just peels off the return
3789 /// type by one layer to yield `T`.
3790 fn make_overloaded_place_return_type(
3792 method: MethodCallee<'tcx>,
3793 ) -> ty::TypeAndMut<'tcx> {
3794 // extract method return type, which will be &T;
3795 let ret_ty = method.sig.output();
3797 // method returns &T, but the type as visible to user is T, so deref
3798 ret_ty.builtin_deref(true).unwrap()
3801 fn check_method_argument_types(
3804 expr: &'tcx hir::Expr<'tcx>,
3805 method: Result<MethodCallee<'tcx>, ()>,
3806 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3807 tuple_arguments: TupleArgumentsFlag,
3808 expected: Expectation<'tcx>,
3810 let has_error = match method {
3811 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3815 let err_inputs = self.err_args(args_no_rcvr.len());
3817 let err_inputs = match tuple_arguments {
3818 DontTupleArguments => err_inputs,
3819 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3822 self.check_argument_types(
3832 return self.tcx.ty_error();
3835 let method = method.unwrap();
3836 // HACK(eddyb) ignore self in the definition (see above).
3837 let expected_arg_tys = self.expected_inputs_for_expected_output(
3840 method.sig.output(),
3841 &method.sig.inputs()[1..],
3843 self.check_argument_types(
3846 &method.sig.inputs()[1..],
3847 &expected_arg_tys[..],
3849 method.sig.c_variadic,
3851 self.tcx.hir().span_if_local(method.def_id),
3856 fn self_type_matches_expected_vid(
3858 trait_ref: ty::PolyTraitRef<'tcx>,
3859 expected_vid: ty::TyVid,
3861 let self_ty = self.shallow_resolve(trait_ref.skip_binder().self_ty());
3863 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3864 trait_ref, self_ty, expected_vid
3866 match self_ty.kind {
3867 ty::Infer(ty::TyVar(found_vid)) => {
3868 // FIXME: consider using `sub_root_var` here so we
3869 // can see through subtyping.
3870 let found_vid = self.root_var(found_vid);
3871 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3872 expected_vid == found_vid
3878 fn obligations_for_self_ty<'b>(
3881 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3884 // FIXME: consider using `sub_root_var` here so we
3885 // can see through subtyping.
3886 let ty_var_root = self.root_var(self_ty);
3888 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3891 self.fulfillment_cx.borrow().pending_obligations()
3896 .pending_obligations()
3898 .filter_map(move |obligation| match obligation.predicate.kind() {
3899 ty::PredicateKind::Projection(ref data) => {
3900 Some((data.to_poly_trait_ref(self.tcx), obligation))
3902 ty::PredicateKind::Trait(ref data, _) => {
3903 Some((data.to_poly_trait_ref(), obligation))
3905 ty::PredicateKind::Subtype(..) => None,
3906 ty::PredicateKind::RegionOutlives(..) => None,
3907 ty::PredicateKind::TypeOutlives(..) => None,
3908 ty::PredicateKind::WellFormed(..) => None,
3909 ty::PredicateKind::ObjectSafe(..) => None,
3910 ty::PredicateKind::ConstEvaluatable(..) => None,
3911 ty::PredicateKind::ConstEquate(..) => None,
3912 // N.B., this predicate is created by breaking down a
3913 // `ClosureType: FnFoo()` predicate, where
3914 // `ClosureType` represents some `Closure`. It can't
3915 // possibly be referring to the current closure,
3916 // because we haven't produced the `Closure` for
3917 // this closure yet; this is exactly why the other
3918 // code is looking for a self type of a unresolved
3919 // inference variable.
3920 ty::PredicateKind::ClosureKind(..) => None,
3922 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3925 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3926 self.obligations_for_self_ty(self_ty)
3927 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3930 /// Generic function that factors out common logic from function calls,
3931 /// method calls and overloaded operators.
3932 fn check_argument_types(
3935 expr: &'tcx hir::Expr<'tcx>,
3936 fn_inputs: &[Ty<'tcx>],
3937 expected_arg_tys: &[Ty<'tcx>],
3938 args: &'tcx [hir::Expr<'tcx>],
3940 tuple_arguments: TupleArgumentsFlag,
3941 def_span: Option<Span>,
3944 // Grab the argument types, supplying fresh type variables
3945 // if the wrong number of arguments were supplied
3946 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3948 // All the input types from the fn signature must outlive the call
3949 // so as to validate implied bounds.
3950 for (&fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3951 self.register_wf_obligation(fn_input_ty.into(), arg_expr.span, traits::MiscObligation);
3954 let expected_arg_count = fn_inputs.len();
3956 let param_count_error = |expected_count: usize,
3961 let (span, start_span, args) = match &expr.kind {
3962 hir::ExprKind::Call(hir::Expr { span, .. }, args) => (*span, *span, &args[..]),
3963 hir::ExprKind::MethodCall(path_segment, span, args, _) => (
3965 // `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
3968 .and_then(|args| args.args.iter().last())
3969 // Account for `foo.bar::<T>()`.
3971 // Skip the closing `>`.
3974 .next_point(tcx.sess.source_map().next_point(arg.span()))
3977 &args[1..], // Skip the receiver.
3979 k => span_bug!(sp, "checking argument types on a non-call: `{:?}`", k),
3981 let arg_spans = if args.is_empty() {
3983 // ^^^-- supplied 0 arguments
3985 // expected 2 arguments
3986 vec![tcx.sess.source_map().next_point(start_span).with_hi(sp.hi())]
3989 // ^^^ - - - supplied 3 arguments
3991 // expected 2 arguments
3992 args.iter().map(|arg| arg.span).collect::<Vec<Span>>()
3995 let mut err = tcx.sess.struct_span_err_with_code(
3998 "this function takes {}{} but {} {} supplied",
3999 if c_variadic { "at least " } else { "" },
4000 potentially_plural_count(expected_count, "argument"),
4001 potentially_plural_count(arg_count, "argument"),
4002 if arg_count == 1 { "was" } else { "were" }
4004 DiagnosticId::Error(error_code.to_owned()),
4006 let label = format!("supplied {}", potentially_plural_count(arg_count, "argument"));
4007 for (i, span) in arg_spans.into_iter().enumerate() {
4010 if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
4014 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().guess_head_span(sp)) {
4015 err.span_label(def_s, "defined here");
4018 let sugg_span = tcx.sess.source_map().end_point(expr.span);
4019 // remove closing `)` from the span
4020 let sugg_span = sugg_span.shrink_to_lo();
4021 err.span_suggestion(
4023 "expected the unit value `()`; create it with empty parentheses",
4025 Applicability::MachineApplicable,
4032 if c_variadic { "at least " } else { "" },
4033 potentially_plural_count(expected_count, "argument")
4040 let mut expected_arg_tys = expected_arg_tys.to_vec();
4042 let formal_tys = if tuple_arguments == TupleArguments {
4043 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
4044 match tuple_type.kind {
4045 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
4046 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
4047 expected_arg_tys = vec![];
4048 self.err_args(args.len())
4050 ty::Tuple(arg_types) => {
4051 expected_arg_tys = match expected_arg_tys.get(0) {
4052 Some(&ty) => match ty.kind {
4053 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
4058 arg_types.iter().map(|k| k.expect_ty()).collect()
4065 "cannot use call notation; the first type parameter \
4066 for the function trait is neither a tuple nor unit"
4069 expected_arg_tys = vec![];
4070 self.err_args(args.len())
4073 } else if expected_arg_count == supplied_arg_count {
4075 } else if c_variadic {
4076 if supplied_arg_count >= expected_arg_count {
4079 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
4080 expected_arg_tys = vec![];
4081 self.err_args(supplied_arg_count)
4084 // is the missing argument of type `()`?
4085 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
4086 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
4087 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
4088 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
4092 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
4094 expected_arg_tys = vec![];
4095 self.err_args(supplied_arg_count)
4099 "check_argument_types: formal_tys={:?}",
4100 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
4103 // If there is no expectation, expect formal_tys.
4104 let expected_arg_tys =
4105 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
4107 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
4109 // Check the arguments.
4110 // We do this in a pretty awful way: first we type-check any arguments
4111 // that are not closures, then we type-check the closures. This is so
4112 // that we have more information about the types of arguments when we
4113 // type-check the functions. This isn't really the right way to do this.
4114 for &check_closures in &[false, true] {
4115 debug!("check_closures={}", check_closures);
4117 // More awful hacks: before we check argument types, try to do
4118 // an "opportunistic" trait resolution of any trait bounds on
4119 // the call. This helps coercions.
4121 self.select_obligations_where_possible(false, |errors| {
4122 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
4123 self.point_at_arg_instead_of_call_if_possible(
4125 &final_arg_types[..],
4132 // For C-variadic functions, we don't have a declared type for all of
4133 // the arguments hence we only do our usual type checking with
4134 // the arguments who's types we do know.
4135 let t = if c_variadic {
4137 } else if tuple_arguments == TupleArguments {
4142 for (i, arg) in args.iter().take(t).enumerate() {
4143 // Warn only for the first loop (the "no closures" one).
4144 // Closure arguments themselves can't be diverging, but
4145 // a previous argument can, e.g., `foo(panic!(), || {})`.
4146 if !check_closures {
4147 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
4150 let is_closure = match arg.kind {
4151 ExprKind::Closure(..) => true,
4155 if is_closure != check_closures {
4159 debug!("checking the argument");
4160 let formal_ty = formal_tys[i];
4162 // The special-cased logic below has three functions:
4163 // 1. Provide as good of an expected type as possible.
4164 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
4166 let checked_ty = self.check_expr_with_expectation(&arg, expected);
4168 // 2. Coerce to the most detailed type that could be coerced
4169 // to, which is `expected_ty` if `rvalue_hint` returns an
4170 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
4171 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
4172 // We're processing function arguments so we definitely want to use
4173 // two-phase borrows.
4174 self.demand_coerce(&arg, checked_ty, coerce_ty, None, AllowTwoPhase::Yes);
4175 final_arg_types.push((i, checked_ty, coerce_ty));
4177 // 3. Relate the expected type and the formal one,
4178 // if the expected type was used for the coercion.
4179 self.demand_suptype(arg.span, formal_ty, coerce_ty);
4183 // We also need to make sure we at least write the ty of the other
4184 // arguments which we skipped above.
4186 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
4187 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
4188 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
4191 for arg in args.iter().skip(expected_arg_count) {
4192 let arg_ty = self.check_expr(&arg);
4194 // There are a few types which get autopromoted when passed via varargs
4195 // in C but we just error out instead and require explicit casts.
4196 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
4198 ty::Float(ast::FloatTy::F32) => {
4199 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
4201 ty::Int(ast::IntTy::I8 | ast::IntTy::I16) | ty::Bool => {
4202 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
4204 ty::Uint(ast::UintTy::U8 | ast::UintTy::U16) => {
4205 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
4208 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
4209 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
4210 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
4218 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
4219 vec![self.tcx.ty_error(); len]
4222 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
4223 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
4224 /// reference a type argument. The reason to walk also the checked type is that the coerced type
4225 /// can be not easily comparable with predicate type (because of coercion). If the types match
4226 /// for either checked or coerced type, and there's only *one* argument that does, we point at
4227 /// the corresponding argument's expression span instead of the `fn` call path span.
4228 fn point_at_arg_instead_of_call_if_possible(
4230 errors: &mut Vec<traits::FulfillmentError<'_>>,
4231 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
4233 args: &'tcx [hir::Expr<'tcx>],
4235 // We *do not* do this for desugared call spans to keep good diagnostics when involving
4236 // the `?` operator.
4237 if call_sp.desugaring_kind().is_some() {
4241 for error in errors {
4242 // Only if the cause is somewhere inside the expression we want try to point at arg.
4243 // Otherwise, it means that the cause is somewhere else and we should not change
4244 // anything because we can break the correct span.
4245 if !call_sp.contains(error.obligation.cause.span) {
4249 if let ty::PredicateKind::Trait(predicate, _) = error.obligation.predicate.kind() {
4250 // Collect the argument position for all arguments that could have caused this
4251 // `FulfillmentError`.
4252 let mut referenced_in = final_arg_types
4254 .map(|&(i, checked_ty, _)| (i, checked_ty))
4255 .chain(final_arg_types.iter().map(|&(i, _, coerced_ty)| (i, coerced_ty)))
4256 .flat_map(|(i, ty)| {
4257 let ty = self.resolve_vars_if_possible(&ty);
4258 // We walk the argument type because the argument's type could have
4259 // been `Option<T>`, but the `FulfillmentError` references `T`.
4260 if ty.walk().any(|arg| arg == predicate.skip_binder().self_ty().into()) {
4266 .collect::<Vec<_>>();
4268 // Both checked and coerced types could have matched, thus we need to remove
4270 referenced_in.sort();
4271 referenced_in.dedup();
4273 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
4274 // We make sure that only *one* argument matches the obligation failure
4275 // and we assign the obligation's span to its expression's.
4276 error.obligation.cause.make_mut().span = args[ref_in].span;
4277 error.points_at_arg_span = true;
4283 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4284 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4285 /// were caused by them. If they were, we point at the corresponding type argument's span
4286 /// instead of the `fn` call path span.
4287 fn point_at_type_arg_instead_of_call_if_possible(
4289 errors: &mut Vec<traits::FulfillmentError<'_>>,
4290 call_expr: &'tcx hir::Expr<'tcx>,
4292 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4293 if let hir::ExprKind::Path(qpath) = &path.kind {
4294 if let hir::QPath::Resolved(_, path) = &qpath {
4295 for error in errors {
4296 if let ty::PredicateKind::Trait(predicate, _) =
4297 error.obligation.predicate.kind()
4299 // If any of the type arguments in this path segment caused the
4300 // `FullfillmentError`, point at its span (#61860).
4304 .filter_map(|seg| seg.args.as_ref())
4305 .flat_map(|a| a.args.iter())
4307 if let hir::GenericArg::Type(hir_ty) = &arg {
4308 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4311 // Avoid ICE with associated types. As this is best
4312 // effort only, it's ok to ignore the case. It
4313 // would trigger in `is_send::<T::AssocType>();`
4314 // from `typeck-default-trait-impl-assoc-type.rs`.
4316 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4317 let ty = self.resolve_vars_if_possible(&ty);
4318 if ty == predicate.skip_binder().self_ty() {
4319 error.obligation.cause.make_mut().span = hir_ty.span;
4331 // AST fragment checking
4332 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4336 ast::LitKind::Str(..) => tcx.mk_static_str(),
4337 ast::LitKind::ByteStr(ref v) => {
4338 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4340 ast::LitKind::Byte(_) => tcx.types.u8,
4341 ast::LitKind::Char(_) => tcx.types.char,
4342 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4343 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4344 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4345 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4346 ty::Int(_) | ty::Uint(_) => Some(ty),
4347 ty::Char => Some(tcx.types.u8),
4348 ty::RawPtr(..) => Some(tcx.types.usize),
4349 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4352 opt_ty.unwrap_or_else(|| self.next_int_var())
4354 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4355 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4356 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4357 ty::Float(_) => Some(ty),
4360 opt_ty.unwrap_or_else(|| self.next_float_var())
4362 ast::LitKind::Bool(_) => tcx.types.bool,
4363 ast::LitKind::Err(_) => tcx.ty_error(),
4367 /// Unifies the output type with the expected type early, for more coercions
4368 /// and forward type information on the input expressions.
4369 fn expected_inputs_for_expected_output(
4372 expected_ret: Expectation<'tcx>,
4373 formal_ret: Ty<'tcx>,
4374 formal_args: &[Ty<'tcx>],
4375 ) -> Vec<Ty<'tcx>> {
4376 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4377 let ret_ty = match expected_ret.only_has_type(self) {
4379 None => return Vec::new(),
4381 let expect_args = self
4382 .fudge_inference_if_ok(|| {
4383 // Attempt to apply a subtyping relationship between the formal
4384 // return type (likely containing type variables if the function
4385 // is polymorphic) and the expected return type.
4386 // No argument expectations are produced if unification fails.
4387 let origin = self.misc(call_span);
4388 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4390 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4391 // to identity so the resulting type is not constrained.
4394 // Process any obligations locally as much as
4395 // we can. We don't care if some things turn
4396 // out unconstrained or ambiguous, as we're
4397 // just trying to get hints here.
4398 self.save_and_restore_in_snapshot_flag(|_| {
4399 let mut fulfill = TraitEngine::new(self.tcx);
4400 for obligation in ok.obligations {
4401 fulfill.register_predicate_obligation(self, obligation);
4403 fulfill.select_where_possible(self)
4407 Err(_) => return Err(()),
4410 // Record all the argument types, with the substitutions
4411 // produced from the above subtyping unification.
4412 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4414 .unwrap_or_default();
4416 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4417 formal_args, formal_ret, expect_args, expected_ret
4422 pub fn check_struct_path(
4426 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4427 let path_span = match *qpath {
4428 QPath::Resolved(_, ref path) => path.span,
4429 QPath::TypeRelative(ref qself, _) => qself.span,
4431 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4432 let variant = match def {
4434 self.set_tainted_by_errors();
4437 Res::Def(DefKind::Variant, _) => match ty.kind {
4438 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4439 _ => bug!("unexpected type: {:?}", ty),
4441 Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
4442 | Res::SelfTy(..) => match ty.kind {
4443 ty::Adt(adt, substs) if !adt.is_enum() => {
4444 Some((adt.non_enum_variant(), adt.did, substs))
4448 _ => bug!("unexpected definition: {:?}", def),
4451 if let Some((variant, did, substs)) = variant {
4452 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4453 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4455 // Check bounds on type arguments used in the path.
4456 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4458 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4459 self.add_obligations_for_parameters(cause, bounds);
4467 "expected struct, variant or union type, found {}",
4468 ty.sort_string(self.tcx)
4470 .span_label(path_span, "not a struct")
4476 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4477 // The newly resolved definition is written into `type_dependent_defs`.
4478 fn finish_resolving_struct_path(
4483 ) -> (Res, Ty<'tcx>) {
4485 QPath::Resolved(ref maybe_qself, ref path) => {
4486 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4487 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4490 QPath::TypeRelative(ref qself, ref segment) => {
4491 let ty = self.to_ty(qself);
4493 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4499 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4500 let ty = result.map(|(ty, _, _)| ty).unwrap_or_else(|_| self.tcx().ty_error());
4501 let result = result.map(|(_, kind, def_id)| (kind, def_id));
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), ty)
4511 /// Resolves an associated value path into a base type and associated constant, or method
4512 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4513 pub fn resolve_ty_and_res_ufcs<'b>(
4515 qpath: &'b QPath<'b>,
4518 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4519 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4520 let (ty, qself, item_segment) = match *qpath {
4521 QPath::Resolved(ref opt_qself, ref path) => {
4524 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4528 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4530 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4531 // Return directly on cache hit. This is useful to avoid doubly reporting
4532 // errors with default match binding modes. See #44614.
4534 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4535 return (def, Some(ty), slice::from_ref(&**item_segment));
4537 let item_name = item_segment.ident;
4538 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4539 let result = match error {
4540 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4541 _ => Err(ErrorReported),
4543 if item_name.name != kw::Invalid {
4544 if let Some(mut e) = self.report_method_error(
4548 SelfSource::QPath(qself),
4558 // Write back the new resolution.
4559 self.write_resolution(hir_id, result);
4561 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4563 slice::from_ref(&**item_segment),
4567 pub fn check_decl_initializer(
4569 local: &'tcx hir::Local<'tcx>,
4570 init: &'tcx hir::Expr<'tcx>,
4572 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4573 // for #42640 (default match binding modes).
4576 let ref_bindings = local.pat.contains_explicit_ref_binding();
4578 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4579 if let Some(m) = ref_bindings {
4580 // Somewhat subtle: if we have a `ref` binding in the pattern,
4581 // we want to avoid introducing coercions for the RHS. This is
4582 // both because it helps preserve sanity and, in the case of
4583 // ref mut, for soundness (issue #23116). In particular, in
4584 // the latter case, we need to be clear that the type of the
4585 // referent for the reference that results is *equal to* the
4586 // type of the place it is referencing, and not some
4587 // supertype thereof.
4588 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4589 self.demand_eqtype(init.span, local_ty, init_ty);
4592 self.check_expr_coercable_to_type(init, local_ty, None)
4596 /// Type check a `let` statement.
4597 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4598 // Determine and write the type which we'll check the pattern against.
4599 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4600 self.write_ty(local.hir_id, ty);
4602 // Type check the initializer.
4603 if let Some(ref init) = local.init {
4604 let init_ty = self.check_decl_initializer(local, &init);
4605 self.overwrite_local_ty_if_err(local, ty, init_ty);
4608 // Does the expected pattern type originate from an expression and what is the span?
4609 let (origin_expr, ty_span) = match (local.ty, local.init) {
4610 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4611 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4612 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4615 // Type check the pattern. Override if necessary to avoid knock-on errors.
4616 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4617 let pat_ty = self.node_ty(local.pat.hir_id);
4618 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4621 fn overwrite_local_ty_if_err(
4623 local: &'tcx hir::Local<'tcx>,
4627 if ty.references_error() {
4628 // Override the types everywhere with `err()` to avoid knock on errors.
4629 self.write_ty(local.hir_id, ty);
4630 self.write_ty(local.pat.hir_id, ty);
4631 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4632 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4633 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4637 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4638 err.span_suggestion_short(
4639 span.shrink_to_hi(),
4640 "consider using a semicolon here",
4642 Applicability::MachineApplicable,
4646 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4647 // Don't do all the complex logic below for `DeclItem`.
4649 hir::StmtKind::Item(..) => return,
4650 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4653 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4655 // Hide the outer diverging and `has_errors` flags.
4656 let old_diverges = self.diverges.replace(Diverges::Maybe);
4657 let old_has_errors = self.has_errors.replace(false);
4660 hir::StmtKind::Local(ref l) => {
4661 self.check_decl_local(&l);
4664 hir::StmtKind::Item(_) => {}
4665 hir::StmtKind::Expr(ref expr) => {
4666 // Check with expected type of `()`.
4667 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4668 self.suggest_semicolon_at_end(expr.span, err);
4671 hir::StmtKind::Semi(ref expr) => {
4672 self.check_expr(&expr);
4676 // Combine the diverging and `has_error` flags.
4677 self.diverges.set(self.diverges.get() | old_diverges);
4678 self.has_errors.set(self.has_errors.get() | old_has_errors);
4681 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4682 let unit = self.tcx.mk_unit();
4683 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4685 // if the block produces a `!` value, that can always be
4686 // (effectively) coerced to unit.
4688 self.demand_suptype(blk.span, unit, ty);
4692 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4693 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4694 /// when given code like the following:
4696 /// if false { return 0i32; } else { 1u32 }
4697 /// // ^^^^ point at this instead of the whole `if` expression
4699 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4700 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4701 let arm_spans: Vec<Span> = arms
4704 self.in_progress_tables
4705 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4706 .and_then(|arm_ty| {
4707 if arm_ty.is_never() {
4710 Some(match &arm.body.kind {
4711 // Point at the tail expression when possible.
4712 hir::ExprKind::Block(block, _) => {
4713 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4721 if arm_spans.len() == 1 {
4722 return arm_spans[0];
4728 fn check_block_with_expected(
4730 blk: &'tcx hir::Block<'tcx>,
4731 expected: Expectation<'tcx>,
4734 let mut fcx_ps = self.ps.borrow_mut();
4735 let unsafety_state = fcx_ps.recurse(blk);
4736 replace(&mut *fcx_ps, unsafety_state)
4739 // In some cases, blocks have just one exit, but other blocks
4740 // can be targeted by multiple breaks. This can happen both
4741 // with labeled blocks as well as when we desugar
4742 // a `try { ... }` expression.
4746 // 'a: { if true { break 'a Err(()); } Ok(()) }
4748 // Here we would wind up with two coercions, one from
4749 // `Err(())` and the other from the tail expression
4750 // `Ok(())`. If the tail expression is omitted, that's a
4751 // "forced unit" -- unless the block diverges, in which
4752 // case we can ignore the tail expression (e.g., `'a: {
4753 // break 'a 22; }` would not force the type of the block
4755 let tail_expr = blk.expr.as_ref();
4756 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4757 let coerce = if blk.targeted_by_break {
4758 CoerceMany::new(coerce_to_ty)
4760 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4761 Some(e) => slice::from_ref(e),
4764 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4767 let prev_diverges = self.diverges.get();
4768 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4770 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4771 for s in blk.stmts {
4775 // check the tail expression **without** holding the
4776 // `enclosing_breakables` lock below.
4777 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4779 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4780 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4781 let coerce = ctxt.coerce.as_mut().unwrap();
4782 if let Some(tail_expr_ty) = tail_expr_ty {
4783 let tail_expr = tail_expr.unwrap();
4784 let span = self.get_expr_coercion_span(tail_expr);
4785 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4786 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4788 // Subtle: if there is no explicit tail expression,
4789 // that is typically equivalent to a tail expression
4790 // of `()` -- except if the block diverges. In that
4791 // case, there is no value supplied from the tail
4792 // expression (assuming there are no other breaks,
4793 // this implies that the type of the block will be
4796 // #41425 -- label the implicit `()` as being the
4797 // "found type" here, rather than the "expected type".
4798 if !self.diverges.get().is_always() {
4799 // #50009 -- Do not point at the entire fn block span, point at the return type
4800 // span, as it is the cause of the requirement, and
4801 // `consider_hint_about_removing_semicolon` will point at the last expression
4802 // if it were a relevant part of the error. This improves usability in editors
4803 // that highlight errors inline.
4804 let mut sp = blk.span;
4805 let mut fn_span = None;
4806 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4807 let ret_sp = decl.output.span();
4808 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4809 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4810 // output would otherwise be incorrect and even misleading. Make sure
4811 // the span we're aiming at correspond to a `fn` body.
4812 if block_sp == blk.span {
4814 fn_span = Some(ident.span);
4818 coerce.coerce_forced_unit(
4822 if let Some(expected_ty) = expected.only_has_type(self) {
4823 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4825 if let Some(fn_span) = fn_span {
4828 "implicitly returns `()` as its body has no tail or `return` \
4840 // If we can break from the block, then the block's exit is always reachable
4841 // (... as long as the entry is reachable) - regardless of the tail of the block.
4842 self.diverges.set(prev_diverges);
4845 let mut ty = ctxt.coerce.unwrap().complete(self);
4847 if self.has_errors.get() || ty.references_error() {
4848 ty = self.tcx.ty_error()
4851 self.write_ty(blk.hir_id, ty);
4853 *self.ps.borrow_mut() = prev;
4857 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4858 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4860 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4861 | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
4862 let body = self.tcx.hir().body(body_id);
4863 if let ExprKind::Block(block, _) = &body.value.kind {
4864 return Some(block.span);
4872 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4873 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, Ident)> {
4874 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4875 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4878 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4879 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl<'tcx>, Ident, bool)> {
4881 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4882 // This is less than ideal, it will not suggest a return type span on any
4883 // method called `main`, regardless of whether it is actually the entry point,
4884 // but it will still present it as the reason for the expected type.
4885 Some((&sig.decl, ident, ident.name != sym::main))
4887 Node::TraitItem(&hir::TraitItem {
4889 kind: hir::TraitItemKind::Fn(ref sig, ..),
4891 }) => Some((&sig.decl, ident, true)),
4892 Node::ImplItem(&hir::ImplItem {
4894 kind: hir::ImplItemKind::Fn(ref sig, ..),
4896 }) => Some((&sig.decl, ident, false)),
4901 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4902 /// suggestion can be made, `None` otherwise.
4903 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4904 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4905 // `while` before reaching it, as block tail returns are not available in them.
4906 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4907 let parent = self.tcx.hir().get(blk_id);
4908 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4912 /// On implicit return expressions with mismatched types, provides the following suggestions:
4914 /// - Points out the method's return type as the reason for the expected type.
4915 /// - Possible missing semicolon.
4916 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4917 pub fn suggest_mismatched_types_on_tail(
4919 err: &mut DiagnosticBuilder<'_>,
4920 expr: &'tcx hir::Expr<'tcx>,
4926 let expr = expr.peel_drop_temps();
4927 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4928 let mut pointing_at_return_type = false;
4929 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4930 pointing_at_return_type =
4931 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4933 pointing_at_return_type
4936 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4937 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4939 /// fn foo(x: usize) -> usize { x }
4940 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4944 err: &mut DiagnosticBuilder<'_>,
4945 expr: &hir::Expr<'_>,
4949 let hir = self.tcx.hir();
4950 let (def_id, sig) = match found.kind {
4951 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4952 ty::Closure(def_id, substs) => (def_id, substs.as_closure().sig()),
4956 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4957 let sig = self.normalize_associated_types_in(expr.span, &sig);
4958 if self.can_coerce(sig.output(), expected) {
4959 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4960 (String::new(), Applicability::MachineApplicable)
4962 ("...".to_string(), Applicability::HasPlaceholders)
4964 let mut msg = "call this function";
4965 match hir.get_if_local(def_id) {
4967 Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. })
4968 | Node::ImplItem(hir::ImplItem {
4969 kind: hir::ImplItemKind::Fn(_, body_id), ..
4971 | Node::TraitItem(hir::TraitItem {
4972 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Provided(body_id)),
4976 let body = hir.body(*body_id);
4980 .map(|param| match ¶m.pat.kind {
4981 hir::PatKind::Binding(_, _, ident, None)
4982 if ident.name != kw::SelfLower =>
4986 _ => "_".to_string(),
4988 .collect::<Vec<_>>()
4991 Some(Node::Expr(hir::Expr {
4992 kind: ExprKind::Closure(_, _, body_id, _, _),
4993 span: full_closure_span,
4996 if *full_closure_span == expr.span {
4999 msg = "call this closure";
5000 let body = hir.body(*body_id);
5004 .map(|param| match ¶m.pat.kind {
5005 hir::PatKind::Binding(_, _, ident, None)
5006 if ident.name != kw::SelfLower =>
5010 _ => "_".to_string(),
5012 .collect::<Vec<_>>()
5015 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
5016 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
5017 match def_id.as_local().map(|def_id| hir.def_kind(def_id)) {
5018 Some(DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
5019 msg = "instantiate this tuple variant";
5021 Some(DefKind::Ctor(CtorOf::Struct, _)) => {
5022 msg = "instantiate this tuple struct";
5027 Some(Node::ForeignItem(hir::ForeignItem {
5028 kind: hir::ForeignItemKind::Fn(_, idents, _),
5034 if ident.name != kw::SelfLower {
5040 .collect::<Vec<_>>()
5043 Some(Node::TraitItem(hir::TraitItem {
5044 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Required(idents)),
5050 if ident.name != kw::SelfLower {
5056 .collect::<Vec<_>>()
5061 err.span_suggestion_verbose(
5062 expr.span.shrink_to_hi(),
5063 &format!("use parentheses to {}", msg),
5064 format!("({})", sugg_call),
5072 pub fn suggest_deref_ref_or_into(
5074 err: &mut DiagnosticBuilder<'_>,
5075 expr: &hir::Expr<'_>,
5078 expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
5080 if let Some((sp, msg, suggestion, applicability)) = self.check_ref(expr, found, expected) {
5081 err.span_suggestion(sp, msg, suggestion, applicability);
5082 } else if let (ty::FnDef(def_id, ..), true) =
5083 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
5085 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
5086 let sp = self.sess().source_map().guess_head_span(sp);
5087 err.span_label(sp, &format!("{} defined here", found));
5089 } else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
5090 let is_struct_pat_shorthand_field =
5091 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
5092 let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
5093 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5094 let mut suggestions = iter::repeat(&expr_text)
5095 .zip(methods.iter())
5096 .filter_map(|(receiver, method)| {
5097 let method_call = format!(".{}()", method.ident);
5098 if receiver.ends_with(&method_call) {
5099 None // do not suggest code that is already there (#53348)
5101 let method_call_list = [".to_vec()", ".to_string()"];
5102 let sugg = if receiver.ends_with(".clone()")
5103 && method_call_list.contains(&method_call.as_str())
5105 let max_len = receiver.rfind('.').unwrap();
5106 format!("{}{}", &receiver[..max_len], method_call)
5108 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
5109 format!("({}){}", receiver, method_call)
5111 format!("{}{}", receiver, method_call)
5114 Some(if is_struct_pat_shorthand_field {
5115 format!("{}: {}", receiver, sugg)
5122 if suggestions.peek().is_some() {
5123 err.span_suggestions(
5125 "try using a conversion method",
5127 Applicability::MaybeIncorrect,
5134 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
5135 /// in the heap by calling `Box::new()`.
5136 fn suggest_boxing_when_appropriate(
5138 err: &mut DiagnosticBuilder<'_>,
5139 expr: &hir::Expr<'_>,
5143 if self.tcx.hir().is_inside_const_context(expr.hir_id) {
5144 // Do not suggest `Box::new` in const context.
5147 if !expected.is_box() || found.is_box() {
5150 let boxed_found = self.tcx.mk_box(found);
5151 if let (true, Ok(snippet)) = (
5152 self.can_coerce(boxed_found, expected),
5153 self.sess().source_map().span_to_snippet(expr.span),
5155 err.span_suggestion(
5157 "store this in the heap by calling `Box::new`",
5158 format!("Box::new({})", snippet),
5159 Applicability::MachineApplicable,
5162 "for more on the distinction between the stack and the heap, read \
5163 https://doc.rust-lang.org/book/ch15-01-box.html, \
5164 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
5165 https://doc.rust-lang.org/std/boxed/index.html",
5170 /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
5171 fn suggest_calling_boxed_future_when_appropriate(
5173 err: &mut DiagnosticBuilder<'_>,
5174 expr: &hir::Expr<'_>,
5180 if self.tcx.hir().is_inside_const_context(expr.hir_id) {
5181 // Do not suggest `Box::new` in const context.
5184 let pin_did = self.tcx.lang_items().pin_type();
5185 match expected.kind {
5186 ty::Adt(def, _) if Some(def.did) != pin_did => return false,
5187 // This guards the `unwrap` and `mk_box` below.
5188 _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
5191 let boxed_found = self.tcx.mk_box(found);
5192 let new_found = self.tcx.mk_lang_item(boxed_found, PinTypeLangItem).unwrap();
5193 if let (true, Ok(snippet)) = (
5194 self.can_coerce(new_found, expected),
5195 self.sess().source_map().span_to_snippet(expr.span),
5198 ty::Adt(def, _) if def.is_box() => {
5199 err.help("use `Box::pin`");
5202 err.span_suggestion(
5204 "you need to pin and box this expression",
5205 format!("Box::pin({})", snippet),
5206 Applicability::MachineApplicable,
5216 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5220 /// bar_that_returns_u32()
5224 /// This routine checks if the return expression in a block would make sense on its own as a
5225 /// statement and the return type has been left as default or has been specified as `()`. If so,
5226 /// it suggests adding a semicolon.
5227 fn suggest_missing_semicolon(
5229 err: &mut DiagnosticBuilder<'_>,
5230 expression: &'tcx hir::Expr<'tcx>,
5234 if expected.is_unit() {
5235 // `BlockTailExpression` only relevant if the tail expr would be
5236 // useful on its own.
5237 match expression.kind {
5239 | ExprKind::MethodCall(..)
5240 | ExprKind::Loop(..)
5241 | ExprKind::Match(..)
5242 | ExprKind::Block(..) => {
5243 err.span_suggestion(
5244 cause_span.shrink_to_hi(),
5245 "try adding a semicolon",
5247 Applicability::MachineApplicable,
5255 /// A possible error is to forget to add a return type that is needed:
5259 /// bar_that_returns_u32()
5263 /// This routine checks if the return type is left as default, the method is not part of an
5264 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5266 fn suggest_missing_return_type(
5268 err: &mut DiagnosticBuilder<'_>,
5269 fn_decl: &hir::FnDecl<'_>,
5274 // Only suggest changing the return type for methods that
5275 // haven't set a return type at all (and aren't `fn main()` or an impl).
5276 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5277 (&hir::FnRetTy::DefaultReturn(span), true, true, true) => {
5278 err.span_suggestion(
5280 "try adding a return type",
5281 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5282 Applicability::MachineApplicable,
5286 (&hir::FnRetTy::DefaultReturn(span), false, true, true) => {
5287 err.span_label(span, "possibly return type missing here?");
5290 (&hir::FnRetTy::DefaultReturn(span), _, false, true) => {
5291 // `fn main()` must return `()`, do not suggest changing return type
5292 err.span_label(span, "expected `()` because of default return type");
5295 // expectation was caused by something else, not the default return
5296 (&hir::FnRetTy::DefaultReturn(_), _, _, false) => false,
5297 (&hir::FnRetTy::Return(ref ty), _, _, _) => {
5298 // Only point to return type if the expected type is the return type, as if they
5299 // are not, the expectation must have been caused by something else.
5300 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5302 let ty = AstConv::ast_ty_to_ty(self, ty);
5303 debug!("suggest_missing_return_type: return type {:?}", ty);
5304 debug!("suggest_missing_return_type: expected type {:?}", ty);
5305 if ty.kind == expected.kind {
5306 err.span_label(sp, format!("expected `{}` because of return type", expected));
5314 /// A possible error is to forget to add `.await` when using futures:
5317 /// async fn make_u32() -> u32 {
5321 /// fn take_u32(x: u32) {}
5323 /// async fn foo() {
5324 /// let x = make_u32();
5329 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5330 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5331 /// `.await` to the tail of the expression.
5332 fn suggest_missing_await(
5334 err: &mut DiagnosticBuilder<'_>,
5335 expr: &hir::Expr<'_>,
5339 debug!("suggest_missing_await: expr={:?} expected={:?}, found={:?}", expr, expected, found);
5340 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5341 // body isn't `async`.
5342 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5343 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5344 let body = self.tcx().hir().body(body_id);
5345 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5347 // Check for `Future` implementations by constructing a predicate to
5348 // prove: `<T as Future>::Output == U`
5349 let future_trait = self.tcx.require_lang_item(FutureTraitLangItem, Some(sp));
5350 let item_def_id = self
5352 .associated_items(future_trait)
5353 .in_definition_order()
5357 // `<T as Future>::Output`
5358 let projection_ty = ty::ProjectionTy {
5362 .mk_substs_trait(found, self.fresh_substs_for_item(sp, item_def_id)),
5368 ty::PredicateKind::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5372 .to_predicate(self.tcx);
5373 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5375 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5377 if self.infcx.predicate_may_hold(&obligation) {
5378 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5379 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5380 err.span_suggestion(
5382 "consider using `.await` here",
5383 format!("{}.await", code),
5384 Applicability::MaybeIncorrect,
5387 debug!("suggest_missing_await: no snippet for {:?}", sp);
5390 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5396 fn note_need_for_fn_pointer(
5398 err: &mut DiagnosticBuilder<'_>,
5402 let (sig, did, substs) = match (&expected.kind, &found.kind) {
5403 (ty::FnDef(did1, substs1), ty::FnDef(did2, substs2)) => {
5404 let sig1 = self.tcx.fn_sig(*did1).subst(self.tcx, substs1);
5405 let sig2 = self.tcx.fn_sig(*did2).subst(self.tcx, substs2);
5410 "different `fn` items always have unique types, even if their signatures are \
5413 (sig1, *did1, substs1)
5415 (ty::FnDef(did, substs), ty::FnPtr(sig2)) => {
5416 let sig1 = self.tcx.fn_sig(*did).subst(self.tcx, substs);
5420 (sig1, *did, substs)
5424 err.help(&format!("change the expected type to be function pointer `{}`", sig));
5426 "if the expected type is due to type inference, cast the expected `fn` to a function \
5427 pointer: `{} as {}`",
5428 self.tcx.def_path_str_with_substs(did, substs),
5433 /// A common error is to add an extra semicolon:
5436 /// fn foo() -> usize {
5441 /// This routine checks if the final statement in a block is an
5442 /// expression with an explicit semicolon whose type is compatible
5443 /// with `expected_ty`. If so, it suggests removing the semicolon.
5444 fn consider_hint_about_removing_semicolon(
5446 blk: &'tcx hir::Block<'tcx>,
5447 expected_ty: Ty<'tcx>,
5448 err: &mut DiagnosticBuilder<'_>,
5450 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5451 err.span_suggestion(
5453 "consider removing this semicolon",
5455 Applicability::MachineApplicable,
5460 fn could_remove_semicolon(
5462 blk: &'tcx hir::Block<'tcx>,
5463 expected_ty: Ty<'tcx>,
5465 // Be helpful when the user wrote `{... expr;}` and
5466 // taking the `;` off is enough to fix the error.
5467 let last_stmt = blk.stmts.last()?;
5468 let last_expr = match last_stmt.kind {
5469 hir::StmtKind::Semi(ref e) => e,
5472 let last_expr_ty = self.node_ty(last_expr.hir_id);
5473 if matches!(last_expr_ty.kind, ty::Error(_))
5474 || self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err()
5478 let original_span = original_sp(last_stmt.span, blk.span);
5479 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5482 // Instantiates the given path, which must refer to an item with the given
5483 // number of type parameters and type.
5484 pub fn instantiate_value_path(
5486 segments: &[hir::PathSegment<'_>],
5487 self_ty: Option<Ty<'tcx>>,
5491 ) -> (Ty<'tcx>, Res) {
5493 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5494 segments, self_ty, res, hir_id,
5499 let path_segs = match res {
5500 Res::Local(_) | Res::SelfCtor(_) => vec![],
5501 Res::Def(kind, def_id) => {
5502 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5504 _ => bug!("instantiate_value_path on {:?}", res),
5507 let mut user_self_ty = None;
5508 let mut is_alias_variant_ctor = false;
5510 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5511 if let Some(self_ty) = self_ty {
5512 let adt_def = self_ty.ty_adt_def().unwrap();
5513 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5514 is_alias_variant_ctor = true;
5517 Res::Def(DefKind::AssocFn | DefKind::AssocConst, def_id) => {
5518 let container = tcx.associated_item(def_id).container;
5519 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5521 ty::TraitContainer(trait_did) => {
5522 callee::check_legal_trait_for_method_call(tcx, span, None, trait_did)
5524 ty::ImplContainer(impl_def_id) => {
5525 if segments.len() == 1 {
5526 // `<T>::assoc` will end up here, and so
5527 // can `T::assoc`. It this came from an
5528 // inherent impl, we need to record the
5529 // `T` for posterity (see `UserSelfTy` for
5531 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5532 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5540 // Now that we have categorized what space the parameters for each
5541 // segment belong to, let's sort out the parameters that the user
5542 // provided (if any) into their appropriate spaces. We'll also report
5543 // errors if type parameters are provided in an inappropriate place.
5545 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5546 let generics_has_err = AstConv::prohibit_generics(
5548 segments.iter().enumerate().filter_map(|(index, seg)| {
5549 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5557 if let Res::Local(hid) = res {
5558 let ty = self.local_ty(span, hid).decl_ty;
5559 let ty = self.normalize_associated_types_in(span, &ty);
5560 self.write_ty(hir_id, ty);
5564 if generics_has_err {
5565 // Don't try to infer type parameters when prohibited generic arguments were given.
5566 user_self_ty = None;
5569 // Now we have to compare the types that the user *actually*
5570 // provided against the types that were *expected*. If the user
5571 // did not provide any types, then we want to substitute inference
5572 // variables. If the user provided some types, we may still need
5573 // to add defaults. If the user provided *too many* types, that's
5576 let mut infer_args_for_err = FxHashSet::default();
5577 for &PathSeg(def_id, index) in &path_segs {
5578 let seg = &segments[index];
5579 let generics = tcx.generics_of(def_id);
5580 // Argument-position `impl Trait` is treated as a normal generic
5581 // parameter internally, but we don't allow users to specify the
5582 // parameter's value explicitly, so we have to do some error-
5584 if let GenericArgCountResult {
5585 correct: Err(GenericArgCountMismatch { reported: Some(ErrorReported), .. }),
5587 } = AstConv::check_generic_arg_count_for_call(
5588 tcx, span, &generics, &seg, false, // `is_method_call`
5590 infer_args_for_err.insert(index);
5591 self.set_tainted_by_errors(); // See issue #53251.
5595 let has_self = path_segs
5597 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5600 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5601 let ty = self.normalize_ty(span, tcx.at(span).type_of(impl_def_id));
5603 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5604 let variant = adt_def.non_enum_variant();
5605 let ctor_def_id = variant.ctor_def_id.unwrap();
5607 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5612 let mut err = tcx.sess.struct_span_err(
5614 "the `Self` constructor can only be used with tuple or unit structs",
5616 if let Some(adt_def) = ty.ty_adt_def() {
5617 match adt_def.adt_kind() {
5619 err.help("did you mean to use one of the enum's variants?");
5621 AdtKind::Struct | AdtKind::Union => {
5622 err.span_suggestion(
5624 "use curly brackets",
5625 String::from("Self { /* fields */ }"),
5626 Applicability::HasPlaceholders,
5633 return (tcx.ty_error(), res);
5639 let def_id = res.def_id();
5641 // The things we are substituting into the type should not contain
5642 // escaping late-bound regions, and nor should the base type scheme.
5643 let ty = tcx.type_of(def_id);
5645 let arg_count = GenericArgCountResult {
5646 explicit_late_bound: ExplicitLateBound::No,
5647 correct: if infer_args_for_err.is_empty() {
5650 Err(GenericArgCountMismatch::default())
5654 let substs = self_ctor_substs.unwrap_or_else(|| {
5655 AstConv::create_substs_for_generic_args(
5662 // Provide the generic args, and whether types should be inferred.
5664 if let Some(&PathSeg(_, index)) =
5665 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5667 // If we've encountered an `impl Trait`-related error, we're just
5668 // going to infer the arguments for better error messages.
5669 if !infer_args_for_err.contains(&index) {
5670 // Check whether the user has provided generic arguments.
5671 if let Some(ref data) = segments[index].args {
5672 return (Some(data), segments[index].infer_args);
5675 return (None, segments[index].infer_args);
5680 // Provide substitutions for parameters for which (valid) arguments have been provided.
5681 |param, arg| match (¶m.kind, arg) {
5682 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5683 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5685 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5686 self.to_ty(ty).into()
5688 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5689 self.const_arg_to_const(&ct.value, param.def_id).into()
5691 _ => unreachable!(),
5693 // Provide substitutions for parameters for which arguments are inferred.
5694 |substs, param, infer_args| {
5696 GenericParamDefKind::Lifetime => {
5697 self.re_infer(Some(param), span).unwrap().into()
5699 GenericParamDefKind::Type { has_default, .. } => {
5700 if !infer_args && has_default {
5701 // If we have a default, then we it doesn't matter that we're not
5702 // inferring the type arguments: we provide the default where any
5704 let default = tcx.type_of(param.def_id);
5707 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5711 // If no type arguments were provided, we have to infer them.
5712 // This case also occurs as a result of some malformed input, e.g.
5713 // a lifetime argument being given instead of a type parameter.
5714 // Using inference instead of `Error` gives better error messages.
5715 self.var_for_def(span, param)
5718 GenericParamDefKind::Const => {
5719 // FIXME(const_generics:defaults)
5720 // No const parameters were provided, we have to infer them.
5721 self.var_for_def(span, param)
5727 assert!(!substs.has_escaping_bound_vars());
5728 assert!(!ty.has_escaping_bound_vars());
5730 // First, store the "user substs" for later.
5731 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5733 self.add_required_obligations(span, def_id, &substs);
5735 // Substitute the values for the type parameters into the type of
5736 // the referenced item.
5737 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5739 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5740 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5741 // is inherent, there is no `Self` parameter; instead, the impl needs
5742 // type parameters, which we can infer by unifying the provided `Self`
5743 // with the substituted impl type.
5744 // This also occurs for an enum variant on a type alias.
5745 let ty = tcx.type_of(impl_def_id);
5747 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5748 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5749 Ok(ok) => self.register_infer_ok_obligations(ok),
5751 self.tcx.sess.delay_span_bug(
5754 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5763 self.check_rustc_args_require_const(def_id, hir_id, span);
5765 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5766 self.write_substs(hir_id, substs);
5768 (ty_substituted, res)
5771 /// Add all the obligations that are required, substituting and normalized appropriately.
5772 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5773 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5775 for (i, mut obligation) in traits::predicates_for_generics(
5776 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5782 // This makes the error point at the bound, but we want to point at the argument
5783 if let Some(span) = spans.get(i) {
5784 obligation.cause.make_mut().code = traits::BindingObligation(def_id, *span);
5786 self.register_predicate(obligation);
5790 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5791 // We're only interested in functions tagged with
5792 // #[rustc_args_required_const], so ignore anything that's not.
5793 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5797 // If our calling expression is indeed the function itself, we're good!
5798 // If not, generate an error that this can only be called directly.
5799 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5800 if let ExprKind::Call(ref callee, ..) = expr.kind {
5801 if callee.hir_id == hir_id {
5807 self.tcx.sess.span_err(
5809 "this function can only be invoked directly, not through a function pointer",
5813 /// Resolves `typ` by a single level if `typ` is a type variable.
5814 /// If no resolution is possible, then an error is reported.
5815 /// Numeric inference variables may be left unresolved.
5816 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5817 let ty = self.resolve_vars_with_obligations(ty);
5818 if !ty.is_ty_var() {
5821 if !self.is_tainted_by_errors() {
5822 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5823 .note("type must be known at this point")
5826 let err = self.tcx.ty_error();
5827 self.demand_suptype(sp, err, ty);
5832 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5835 ctxt: BreakableCtxt<'tcx>,
5837 ) -> (BreakableCtxt<'tcx>, R) {
5840 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5841 index = enclosing_breakables.stack.len();
5842 enclosing_breakables.by_id.insert(id, index);
5843 enclosing_breakables.stack.push(ctxt);
5847 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5848 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5849 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5850 enclosing_breakables.stack.pop().expect("missing breakable context")
5855 /// Instantiate a QueryResponse in a probe context, without a
5856 /// good ObligationCause.
5857 fn probe_instantiate_query_response(
5860 original_values: &OriginalQueryValues<'tcx>,
5861 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5862 ) -> InferResult<'tcx, Ty<'tcx>> {
5863 self.instantiate_query_response_and_region_obligations(
5864 &traits::ObligationCause::misc(span, self.body_id),
5871 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5872 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5873 let mut contained_in_place = false;
5875 while let hir::Node::Expr(parent_expr) =
5876 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5878 match &parent_expr.kind {
5879 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5880 if lhs.hir_id == expr_id {
5881 contained_in_place = true;
5887 expr_id = parent_expr.hir_id;
5894 fn check_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5895 debug!("check_type_params_are_used(generics={:?}, ty={:?})", generics, ty);
5897 assert_eq!(generics.parent, None);
5899 if generics.own_counts().types == 0 {
5903 let mut params_used = BitSet::new_empty(generics.params.len());
5905 if ty.references_error() {
5906 // If there is already another error, do not emit
5907 // an error for not using a type parameter.
5908 assert!(tcx.sess.has_errors());
5912 for leaf in ty.walk() {
5913 if let GenericArgKind::Type(leaf_ty) = leaf.unpack() {
5914 if let ty::Param(param) = leaf_ty.kind {
5915 debug!("found use of ty param {:?}", param);
5916 params_used.insert(param.index);
5921 for param in &generics.params {
5922 if !params_used.contains(param.index) {
5923 if let ty::GenericParamDefKind::Type { .. } = param.kind {
5924 let span = tcx.def_span(param.def_id);
5929 "type parameter `{}` is unused",
5932 .span_label(span, "unused type parameter")
5939 fn fatally_break_rust(sess: &Session) {
5940 let handler = sess.diagnostic();
5941 handler.span_bug_no_panic(
5943 "It looks like you're trying to break rust; would you like some ICE?",
5945 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5946 handler.note_without_error(
5947 "we would appreciate a joke overview: \
5948 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5950 handler.note_without_error(&format!(
5951 "rustc {} running on {}",
5952 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5953 config::host_triple(),
5957 fn potentially_plural_count(count: usize, word: &str) -> String {
5958 format!("{} {}{}", count, word, pluralize!(count))