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, Item, 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 {
768 diagnostic_only_typeck_tables_of,
772 check_item_well_formed,
773 check_trait_item_well_formed,
774 check_impl_item_well_formed,
775 check_mod_item_types,
780 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
781 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
784 /// If this `DefId` is a "primary tables entry", returns
785 /// `Some((body_id, header, decl))` with information about
786 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
789 /// If this function returns `Some`, then `typeck_tables(def_id)` will
790 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
791 /// may not succeed. In some cases where this function returns `None`
792 /// (notably closures), `typeck_tables(def_id)` would wind up
793 /// redirecting to the owning function.
797 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
798 match tcx.hir().get(id) {
799 Node::Item(item) => match item.kind {
800 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
801 Some((body, Some(ty), None, None))
803 hir::ItemKind::Fn(ref sig, .., body) => {
804 Some((body, None, Some(&sig.header), Some(&sig.decl)))
808 Node::TraitItem(item) => match item.kind {
809 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
810 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
811 Some((body, None, Some(&sig.header), Some(&sig.decl)))
815 Node::ImplItem(item) => match item.kind {
816 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
817 hir::ImplItemKind::Fn(ref sig, body) => {
818 Some((body, None, Some(&sig.header), Some(&sig.decl)))
822 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
827 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
828 // Closures' tables come from their outermost function,
829 // as they are part of the same "inference environment".
830 let outer_def_id = tcx.closure_base_def_id(def_id);
831 if outer_def_id != def_id {
832 return tcx.has_typeck_tables(outer_def_id);
835 if let Some(def_id) = def_id.as_local() {
836 let id = tcx.hir().local_def_id_to_hir_id(def_id);
837 primary_body_of(tcx, id).is_some()
843 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &FxHashSet<LocalDefId> {
844 &*tcx.typeck_tables_of(def_id).used_trait_imports
847 /// Inspects the substs of opaque types, replacing any inference variables
848 /// with proper generic parameter from the identity substs.
850 /// This is run after we normalize the function signature, to fix any inference
851 /// variables introduced by the projection of associated types. This ensures that
852 /// any opaque types used in the signature continue to refer to generic parameters,
853 /// allowing them to be considered for defining uses in the function body
855 /// For example, consider this code.
860 /// fn use_it(self) -> Self::MyItem
862 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
863 /// type MyItem = impl Iterator<Item = I>;
864 /// fn use_it(self) -> Self::MyItem {
870 /// When we normalize the signature of `use_it` from the impl block,
871 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
872 /// However, this projection result may contain inference variables, due
873 /// to the way that projection works. We didn't have any inference variables
874 /// in the signature to begin with - leaving them in will cause us to incorrectly
875 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
876 /// variables back to the actual generic parameters, we will correctly see that
877 /// we have a defining use of `MyItem`
878 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
880 T: TypeFoldable<'tcx>,
882 struct FixupFolder<'tcx> {
886 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
887 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
891 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
893 ty::Opaque(def_id, substs) => {
894 debug!("fixup_opaque_types: found type {:?}", ty);
895 // Here, we replace any inference variables that occur within
896 // the substs of an opaque type. By definition, any type occurring
897 // in the substs has a corresponding generic parameter, which is what
898 // we replace it with.
899 // This replacement is only run on the function signature, so any
900 // inference variables that we come across must be the rust of projection
901 // (there's no other way for a user to get inference variables into
902 // a function signature).
903 if ty.needs_infer() {
904 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
905 let old_param = substs[param.index as usize];
906 match old_param.unpack() {
907 GenericArgKind::Type(old_ty) => {
908 if let ty::Infer(_) = old_ty.kind {
909 // Replace inference type with a generic parameter
910 self.tcx.mk_param_from_def(param)
912 old_param.fold_with(self)
915 GenericArgKind::Const(old_const) => {
916 if let ty::ConstKind::Infer(_) = old_const.val {
917 // This should never happen - we currently do not support
918 // 'const projections', e.g.:
919 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
920 // which should be the only way for us to end up with a const inference
921 // variable after projection. If Rust ever gains support for this kind
922 // of projection, this should *probably* be changed to
923 // `self.tcx.mk_param_from_def(param)`
925 "Found infer const: `{:?}` in opaque type: {:?}",
930 old_param.fold_with(self)
933 GenericArgKind::Lifetime(old_region) => {
934 if let RegionKind::ReVar(_) = old_region {
935 self.tcx.mk_param_from_def(param)
937 old_param.fold_with(self)
942 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
943 debug!("fixup_opaque_types: new type: {:?}", new_ty);
949 _ => ty.super_fold_with(self),
954 debug!("fixup_opaque_types({:?})", val);
955 val.fold_with(&mut FixupFolder { tcx })
958 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckTables<'tcx> {
959 let fallback = move || tcx.type_of(def_id.to_def_id());
960 typeck_tables_of_with_fallback(tcx, def_id, fallback)
963 /// Used only to get `TypeckTables` for type inference during error recovery.
964 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
965 fn diagnostic_only_typeck_tables_of<'tcx>(
968 ) -> &ty::TypeckTables<'tcx> {
969 let fallback = move || {
970 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id));
971 tcx.ty_error_with_message(span, "diagnostic only typeck table used")
973 typeck_tables_of_with_fallback(tcx, def_id, fallback)
976 fn typeck_tables_of_with_fallback<'tcx>(
979 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
980 ) -> &'tcx ty::TypeckTables<'tcx> {
981 // Closures' tables come from their outermost function,
982 // as they are part of the same "inference environment".
983 let outer_def_id = tcx.closure_base_def_id(def_id.to_def_id()).expect_local();
984 if outer_def_id != def_id {
985 return tcx.typeck_tables_of(outer_def_id);
988 let id = tcx.hir().as_local_hir_id(def_id);
989 let span = tcx.hir().span(id);
991 // Figure out what primary body this item has.
992 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
993 span_bug!(span, "can't type-check body of {:?}", def_id);
995 let body = tcx.hir().body(body_id);
997 let tables = Inherited::build(tcx, def_id).enter(|inh| {
998 let param_env = tcx.param_env(def_id);
999 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1000 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1001 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1007 &hir::Generics::empty(),
1014 check_abi(tcx, span, fn_sig.abi());
1016 // Compute the fty from point of view of inside the fn.
1017 let fn_sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), &fn_sig);
1018 let fn_sig = inh.normalize_associated_types_in(
1025 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1027 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1030 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1031 let expected_type = body_ty
1032 .and_then(|ty| match ty.kind {
1033 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1036 .unwrap_or_else(fallback);
1037 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1038 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1040 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1041 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1046 // Gather locals in statics (because of block expressions).
1047 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1049 fcx.check_expr_coercable_to_type(&body.value, revealed_ty, None);
1051 fcx.write_ty(id, revealed_ty);
1056 // All type checking constraints were added, try to fallback unsolved variables.
1057 fcx.select_obligations_where_possible(false, |_| {});
1058 let mut fallback_has_occurred = false;
1060 // We do fallback in two passes, to try to generate
1061 // better error messages.
1062 // The first time, we do *not* replace opaque types.
1063 for ty in &fcx.unsolved_variables() {
1064 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1066 // We now see if we can make progress. This might
1067 // cause us to unify inference variables for opaque types,
1068 // since we may have unified some other type variables
1069 // during the first phase of fallback.
1070 // This means that we only replace inference variables with their underlying
1071 // opaque types as a last resort.
1073 // In code like this:
1076 // type MyType = impl Copy;
1077 // fn produce() -> MyType { true }
1078 // fn bad_produce() -> MyType { panic!() }
1081 // we want to unify the opaque inference variable in `bad_produce`
1082 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1083 // This will produce a nice error message about conflicting concrete
1084 // types for `MyType`.
1086 // If we had tried to fallback the opaque inference variable to `MyType`,
1087 // we will generate a confusing type-check error that does not explicitly
1088 // refer to opaque types.
1089 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1091 // We now run fallback again, but this time we allow it to replace
1092 // unconstrained opaque type variables, in addition to performing
1093 // other kinds of fallback.
1094 for ty in &fcx.unsolved_variables() {
1095 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1098 // See if we can make any more progress.
1099 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1101 // Even though coercion casts provide type hints, we check casts after fallback for
1102 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1105 // Closure and generator analysis may run after fallback
1106 // because they don't constrain other type variables.
1107 fcx.closure_analyze(body);
1108 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1109 fcx.resolve_generator_interiors(def_id.to_def_id());
1111 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1112 let ty = fcx.normalize_ty(span, ty);
1113 fcx.require_type_is_sized(ty, span, code);
1116 fcx.select_all_obligations_or_error();
1118 if fn_decl.is_some() {
1119 fcx.regionck_fn(id, body);
1121 fcx.regionck_expr(body);
1124 fcx.resolve_type_vars_in_body(body)
1127 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1128 // it will need to hold.
1129 assert_eq!(tables.hir_owner, id.owner);
1134 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1135 if !tcx.sess.target.target.is_abi_supported(abi) {
1140 "The ABI `{}` is not supported for the current target",
1147 struct GatherLocalsVisitor<'a, 'tcx> {
1148 fcx: &'a FnCtxt<'a, 'tcx>,
1149 parent_id: hir::HirId,
1152 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1153 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1156 // Infer the variable's type.
1157 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1158 kind: TypeVariableOriginKind::TypeInference,
1164 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1168 // Take type that the user specified.
1169 self.fcx.locals.borrow_mut().insert(nid, typ);
1176 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1177 type Map = intravisit::ErasedMap<'tcx>;
1179 fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
1180 NestedVisitorMap::None
1183 // Add explicitly-declared locals.
1184 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1185 let local_ty = match local.ty {
1187 let o_ty = self.fcx.to_ty(&ty);
1189 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1190 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1199 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1201 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1202 ty.hir_id, o_ty, revealed_ty, c_ty
1204 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1206 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1210 self.assign(local.span, local.hir_id, local_ty);
1213 "local variable {:?} is assigned type {}",
1215 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&local.hir_id).unwrap().decl_ty)
1217 intravisit::walk_local(self, local);
1220 // Add pattern bindings.
1221 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1222 if let PatKind::Binding(_, _, ident, _) = p.kind {
1223 let var_ty = self.assign(p.span, p.hir_id, None);
1225 if !self.fcx.tcx.features().unsized_locals {
1226 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1230 "pattern binding {} is assigned to {} with type {:?}",
1232 self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&p.hir_id).unwrap().decl_ty),
1236 intravisit::walk_pat(self, p);
1239 // Don't descend into the bodies of nested closures.
1242 _: intravisit::FnKind<'tcx>,
1243 _: &'tcx hir::FnDecl<'tcx>,
1251 /// When `check_fn` is invoked on a generator (i.e., a body that
1252 /// includes yield), it returns back some information about the yield
1254 struct GeneratorTypes<'tcx> {
1255 /// Type of generator argument / values returned by `yield`.
1256 resume_ty: Ty<'tcx>,
1258 /// Type of value that is yielded.
1261 /// Types that are captured (see `GeneratorInterior` for more).
1264 /// Indicates if the generator is movable or static (immovable).
1265 movability: hir::Movability,
1268 /// Helper used for fns and closures. Does the grungy work of checking a function
1269 /// body and returns the function context used for that purpose, since in the case of a fn item
1270 /// there is still a bit more to do.
1273 /// * inherited: other fields inherited from the enclosing fn (if any)
1274 fn check_fn<'a, 'tcx>(
1275 inherited: &'a Inherited<'a, 'tcx>,
1276 param_env: ty::ParamEnv<'tcx>,
1277 fn_sig: ty::FnSig<'tcx>,
1278 decl: &'tcx hir::FnDecl<'tcx>,
1280 body: &'tcx hir::Body<'tcx>,
1281 can_be_generator: Option<hir::Movability>,
1282 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1283 let mut fn_sig = fn_sig;
1285 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1287 // Create the function context. This is either derived from scratch or,
1288 // in the case of closures, based on the outer context.
1289 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1290 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1293 let sess = tcx.sess;
1294 let hir = tcx.hir();
1296 let declared_ret_ty = fn_sig.output();
1297 let revealed_ret_ty =
1298 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1299 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1300 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1301 fn_sig = tcx.mk_fn_sig(
1302 fn_sig.inputs().iter().cloned(),
1309 let span = body.value.span;
1311 fn_maybe_err(tcx, span, fn_sig.abi);
1313 if body.generator_kind.is_some() && can_be_generator.is_some() {
1315 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1316 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1318 // Resume type defaults to `()` if the generator has no argument.
1319 let resume_ty = fn_sig.inputs().get(0).copied().unwrap_or_else(|| tcx.mk_unit());
1321 fcx.resume_yield_tys = Some((resume_ty, yield_ty));
1324 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id).to_def_id()).expect_local();
1325 let outer_hir_id = hir.as_local_hir_id(outer_def_id);
1326 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1328 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1329 // (as it's created inside the body itself, not passed in from outside).
1330 let maybe_va_list = if fn_sig.c_variadic {
1331 let span = body.params.last().unwrap().span;
1332 let va_list_did = tcx.require_lang_item(VaListTypeLangItem, Some(span));
1333 let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span));
1335 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1340 // Add formal parameters.
1341 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1342 let inputs_fn = fn_sig.inputs().iter().copied();
1343 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1344 // Check the pattern.
1345 fcx.check_pat_top(¶m.pat, param_ty, try { inputs_hir?.get(idx)?.span }, false);
1347 // Check that argument is Sized.
1348 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1349 // for simple cases like `fn foo(x: Trait)`,
1350 // where we would error once on the parameter as a whole, and once on the binding `x`.
1351 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1352 fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType);
1355 fcx.write_ty(param.hir_id, param_ty);
1358 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1360 if let ty::Dynamic(..) = declared_ret_ty.kind {
1361 // FIXME: We need to verify that the return type is `Sized` after the return expression has
1362 // been evaluated so that we have types available for all the nodes being returned, but that
1363 // requires the coerced evaluated type to be stored. Moving `check_return_expr` before this
1364 // causes unsized errors caused by the `declared_ret_ty` to point at the return expression,
1365 // while keeping the current ordering we will ignore the tail expression's type because we
1366 // don't know it yet. We can't do `check_expr_kind` while keeping `check_return_expr`
1367 // because we will trigger "unreachable expression" lints unconditionally.
1368 // Because of all of this, we perform a crude check to know whether the simplest `!Sized`
1369 // case that a newcomer might make, returning a bare trait, and in that case we populate
1370 // the tail expression's type so that the suggestion will be correct, but ignore all other
1372 fcx.check_expr(&body.value);
1373 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1374 tcx.sess.delay_span_bug(decl.output.span(), "`!Sized` return type");
1376 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1377 fcx.check_return_expr(&body.value);
1380 // We insert the deferred_generator_interiors entry after visiting the body.
1381 // This ensures that all nested generators appear before the entry of this generator.
1382 // resolve_generator_interiors relies on this property.
1383 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1385 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1386 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1388 let (resume_ty, yield_ty) = fcx.resume_yield_tys.unwrap();
1389 Some(GeneratorTypes {
1393 movability: can_be_generator.unwrap(),
1399 // Finalize the return check by taking the LUB of the return types
1400 // we saw and assigning it to the expected return type. This isn't
1401 // really expected to fail, since the coercions would have failed
1402 // earlier when trying to find a LUB.
1404 // However, the behavior around `!` is sort of complex. In the
1405 // event that the `actual_return_ty` comes back as `!`, that
1406 // indicates that the fn either does not return or "returns" only
1407 // values of type `!`. In this case, if there is an expected
1408 // return type that is *not* `!`, that should be ok. But if the
1409 // return type is being inferred, we want to "fallback" to `!`:
1411 // let x = move || panic!();
1413 // To allow for that, I am creating a type variable with diverging
1414 // fallback. This was deemed ever so slightly better than unifying
1415 // the return value with `!` because it allows for the caller to
1416 // make more assumptions about the return type (e.g., they could do
1418 // let y: Option<u32> = Some(x());
1420 // which would then cause this return type to become `u32`, not
1422 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1423 let mut actual_return_ty = coercion.complete(&fcx);
1424 if actual_return_ty.is_never() {
1425 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1426 kind: TypeVariableOriginKind::DivergingFn,
1430 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1432 // Check that the main return type implements the termination trait.
1433 if let Some(term_id) = tcx.lang_items().termination() {
1434 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1435 let main_id = hir.as_local_hir_id(def_id);
1436 if main_id == fn_id {
1437 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1438 let trait_ref = ty::TraitRef::new(term_id, substs);
1439 let return_ty_span = decl.output.span();
1440 let cause = traits::ObligationCause::new(
1443 ObligationCauseCode::MainFunctionType,
1446 inherited.register_predicate(traits::Obligation::new(
1449 trait_ref.without_const().to_predicate(tcx),
1455 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1456 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1457 if panic_impl_did == hir.local_def_id(fn_id).to_def_id() {
1458 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1459 if declared_ret_ty.kind != ty::Never {
1460 sess.span_err(decl.output.span(), "return type should be `!`");
1463 let inputs = fn_sig.inputs();
1464 let span = hir.span(fn_id);
1465 if inputs.len() == 1 {
1466 let arg_is_panic_info = match inputs[0].kind {
1467 ty::Ref(region, ty, mutbl) => match ty.kind {
1468 ty::Adt(ref adt, _) => {
1469 adt.did == panic_info_did
1470 && mutbl == hir::Mutability::Not
1471 && *region != RegionKind::ReStatic
1478 if !arg_is_panic_info {
1479 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1482 if let Node::Item(item) = hir.get(fn_id) {
1483 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1484 if !generics.params.is_empty() {
1485 sess.span_err(span, "should have no type parameters");
1490 let span = sess.source_map().guess_head_span(span);
1491 sess.span_err(span, "function should have one argument");
1494 sess.err("language item required, but not found: `panic_info`");
1499 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1500 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1501 if alloc_error_handler_did == hir.local_def_id(fn_id).to_def_id() {
1502 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1503 if declared_ret_ty.kind != ty::Never {
1504 sess.span_err(decl.output.span(), "return type should be `!`");
1507 let inputs = fn_sig.inputs();
1508 let span = hir.span(fn_id);
1509 if inputs.len() == 1 {
1510 let arg_is_alloc_layout = match inputs[0].kind {
1511 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1515 if !arg_is_alloc_layout {
1516 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1519 if let Node::Item(item) = hir.get(fn_id) {
1520 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1521 if !generics.params.is_empty() {
1524 "`#[alloc_error_handler]` function should have no type \
1531 let span = sess.source_map().guess_head_span(span);
1532 sess.span_err(span, "function should have one argument");
1535 sess.err("language item required, but not found: `alloc_layout`");
1543 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1544 let def_id = tcx.hir().local_def_id(id);
1545 let def = tcx.adt_def(def_id);
1546 def.destructor(tcx); // force the destructor to be evaluated
1547 check_representable(tcx, span, def_id);
1549 if def.repr.simd() {
1550 check_simd(tcx, span, def_id);
1553 check_transparent(tcx, span, def);
1554 check_packed(tcx, span, def);
1557 fn check_union(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);
1562 check_transparent(tcx, span, def);
1563 check_union_fields(tcx, span, def_id);
1564 check_packed(tcx, span, def);
1567 /// When the `#![feature(untagged_unions)]` gate is active,
1568 /// check that the fields of the `union` does not contain fields that need dropping.
1569 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: LocalDefId) -> bool {
1570 let item_type = tcx.type_of(item_def_id);
1571 if let ty::Adt(def, substs) = item_type.kind {
1572 assert!(def.is_union());
1573 let fields = &def.non_enum_variant().fields;
1574 let param_env = tcx.param_env(item_def_id);
1575 for field in fields {
1576 let field_ty = field.ty(tcx, substs);
1577 // We are currently checking the type this field came from, so it must be local.
1578 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1579 if field_ty.needs_drop(tcx, param_env) {
1584 "unions may not contain fields that need dropping"
1586 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1592 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1597 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1598 /// projections that would result in "inheriting lifetimes".
1599 fn check_opaque<'tcx>(
1602 substs: SubstsRef<'tcx>,
1604 origin: &hir::OpaqueTyOrigin,
1606 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1607 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1610 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1611 /// in "inheriting lifetimes".
1612 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) {
1613 let item = tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id));
1615 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1620 struct ProhibitOpaqueVisitor<'tcx> {
1621 opaque_identity_ty: Ty<'tcx>,
1622 generics: &'tcx ty::Generics,
1623 ty: Option<Ty<'tcx>>,
1626 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1627 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1628 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1629 if t != self.opaque_identity_ty && t.super_visit_with(self) {
1636 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1637 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1638 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1639 return *index < self.generics.parent_count as u32;
1642 r.super_visit_with(self)
1645 fn visit_const(&mut self, c: &'tcx ty::Const<'tcx>) -> bool {
1646 if let ty::ConstKind::Unevaluated(..) = c.val {
1647 // FIXME(#72219) We currenctly don't detect lifetimes within substs
1648 // which would violate this check. Even though the particular substitution is not used
1649 // within the const, this should still be fixed.
1652 c.super_visit_with(self)
1656 if let ItemKind::OpaqueTy(hir::OpaqueTy {
1657 origin: hir::OpaqueTyOrigin::AsyncFn | hir::OpaqueTyOrigin::FnReturn,
1661 let mut visitor = ProhibitOpaqueVisitor {
1662 opaque_identity_ty: tcx.mk_opaque(
1664 InternalSubsts::identity_for_item(tcx, def_id.to_def_id()),
1666 generics: tcx.generics_of(def_id),
1669 let prohibit_opaque = tcx
1670 .predicates_of(def_id)
1673 .any(|(predicate, _)| predicate.visit_with(&mut visitor));
1675 "check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}, visitor={:?}",
1676 prohibit_opaque, visitor
1679 if prohibit_opaque {
1680 let is_async = match item.kind {
1681 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1682 hir::OpaqueTyOrigin::AsyncFn => true,
1685 _ => unreachable!(),
1688 let mut err = struct_span_err!(
1692 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1694 if is_async { "async fn" } else { "impl Trait" },
1697 if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(span) {
1698 if snippet == "Self" {
1699 if let Some(ty) = visitor.ty {
1700 err.span_suggestion(
1702 "consider spelling out the type instead",
1703 format!("{:?}", ty),
1704 Applicability::MaybeIncorrect,
1714 /// Given a `DefId` for an opaque type in return position, find its parent item's return
1716 fn get_owner_return_paths(
1719 ) -> Option<(hir::HirId, ReturnsVisitor<'tcx>)> {
1720 let hir_id = tcx.hir().as_local_hir_id(def_id);
1721 let id = tcx.hir().get_parent_item(hir_id);
1725 .and_then(|(hir_id, node)| node.body_id().map(|b| (hir_id, b)))
1726 .map(|(hir_id, body_id)| {
1727 let body = tcx.hir().body(body_id);
1728 let mut visitor = ReturnsVisitor::default();
1729 visitor.visit_body(body);
1734 /// Emit an error for recursive opaque types.
1736 /// If this is a return `impl Trait`, find the item's return expressions and point at them. For
1737 /// direct recursion this is enough, but for indirect recursion also point at the last intermediary
1740 /// If all the return expressions evaluate to `!`, then we explain that the error will go away
1741 /// after changing it. This can happen when a user uses `panic!()` or similar as a placeholder.
1742 fn opaque_type_cycle_error(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) {
1743 let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type");
1745 let mut label = false;
1746 if let Some((hir_id, visitor)) = get_owner_return_paths(tcx, def_id) {
1747 let tables = tcx.typeck_tables_of(tcx.hir().local_def_id(hir_id));
1751 .filter_map(|expr| tables.node_type_opt(expr.hir_id))
1752 .all(|ty| matches!(ty.kind, ty::Never))
1757 .filter(|expr| tables.node_type_opt(expr.hir_id).is_some())
1758 .map(|expr| expr.span)
1759 .collect::<Vec<Span>>();
1760 let span_len = spans.len();
1762 err.span_label(spans[0], "this returned value is of `!` type");
1764 let mut multispan: MultiSpan = spans.clone().into();
1767 .push_span_label(span, "this returned value is of `!` type".to_string());
1769 err.span_note(multispan, "these returned values have a concrete \"never\" type");
1771 err.help("this error will resolve once the item's body returns a concrete type");
1773 let mut seen = FxHashSet::default();
1775 err.span_label(span, "recursive opaque type");
1777 for (sp, ty) in visitor
1780 .filter_map(|e| tables.node_type_opt(e.hir_id).map(|t| (e.span, t)))
1781 .filter(|(_, ty)| !matches!(ty.kind, ty::Never))
1783 struct VisitTypes(Vec<DefId>);
1784 impl<'tcx> ty::fold::TypeVisitor<'tcx> for VisitTypes {
1785 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1787 ty::Opaque(def, _) => {
1791 _ => t.super_visit_with(self),
1795 let mut visitor = VisitTypes(vec![]);
1796 ty.visit_with(&mut visitor);
1797 for def_id in visitor.0 {
1798 let ty_span = tcx.def_span(def_id);
1799 if !seen.contains(&ty_span) {
1800 err.span_label(ty_span, &format!("returning this opaque type `{}`", ty));
1801 seen.insert(ty_span);
1803 err.span_label(sp, &format!("returning here with type `{}`", ty));
1809 err.span_label(span, "cannot resolve opaque type");
1814 /// Emit an error for recursive opaque types in a `let` binding.
1815 fn binding_opaque_type_cycle_error(
1819 partially_expanded_type: Ty<'tcx>,
1821 let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type");
1822 err.span_label(span, "cannot resolve opaque type");
1823 // Find the the owner that declared this `impl Trait` type.
1824 let hir_id = tcx.hir().as_local_hir_id(def_id);
1825 let mut prev_hir_id = hir_id;
1826 let mut hir_id = tcx.hir().get_parent_node(hir_id);
1827 while let Some(node) = tcx.hir().find(hir_id) {
1829 hir::Node::Local(hir::Local {
1833 source: hir::LocalSource::Normal,
1836 err.span_label(pat.span, "this binding might not have a concrete type");
1837 err.span_suggestion_verbose(
1838 ty.span.shrink_to_hi(),
1839 "set the binding to a value for a concrete type to be resolved",
1840 " = /* value */".to_string(),
1841 Applicability::HasPlaceholders,
1844 hir::Node::Local(hir::Local {
1846 source: hir::LocalSource::Normal,
1849 let hir_id = tcx.hir().as_local_hir_id(def_id);
1851 tcx.typeck_tables_of(tcx.hir().local_def_id(tcx.hir().get_parent_item(hir_id)));
1852 if let Some(ty) = tables.node_type_opt(expr.hir_id) {
1856 "this is of type `{}`, which doesn't constrain \
1857 `{}` enough to arrive to a concrete type",
1858 ty, partially_expanded_type
1865 if prev_hir_id == hir_id {
1868 prev_hir_id = hir_id;
1869 hir_id = tcx.hir().get_parent_node(hir_id);
1874 fn async_opaque_type_cycle_error(tcx: TyCtxt<'tcx>, span: Span) {
1875 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing")
1876 .span_label(span, "recursive `async fn`")
1877 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
1881 /// Checks that an opaque type does not contain cycles.
1882 fn check_opaque_for_cycles<'tcx>(
1885 substs: SubstsRef<'tcx>,
1887 origin: &hir::OpaqueTyOrigin,
1889 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id.to_def_id(), substs)
1892 hir::OpaqueTyOrigin::AsyncFn => async_opaque_type_cycle_error(tcx, span),
1893 hir::OpaqueTyOrigin::Binding => {
1894 binding_opaque_type_cycle_error(tcx, def_id, span, partially_expanded_type)
1896 _ => opaque_type_cycle_error(tcx, def_id, span),
1901 // Forbid defining intrinsics in Rust code,
1902 // as they must always be defined by the compiler.
1903 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1904 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1905 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1909 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1911 "check_item_type(it.hir_id={}, it.name={})",
1913 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id).to_def_id())
1915 let _indenter = indenter();
1917 // Consts can play a role in type-checking, so they are included here.
1918 hir::ItemKind::Static(..) => {
1919 let def_id = tcx.hir().local_def_id(it.hir_id);
1920 tcx.ensure().typeck_tables_of(def_id);
1921 maybe_check_static_with_link_section(tcx, def_id, it.span);
1923 hir::ItemKind::Const(..) => {
1924 tcx.ensure().typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1926 hir::ItemKind::Enum(ref enum_definition, _) => {
1927 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1929 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1930 hir::ItemKind::Impl { ref items, .. } => {
1931 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1932 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1933 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1934 check_impl_items_against_trait(tcx, it.span, impl_def_id, impl_trait_ref, items);
1935 let trait_def_id = impl_trait_ref.def_id;
1936 check_on_unimplemented(tcx, trait_def_id, it);
1939 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1940 let def_id = tcx.hir().local_def_id(it.hir_id);
1941 check_on_unimplemented(tcx, def_id.to_def_id(), it);
1943 for item in items.iter() {
1944 let item = tcx.hir().trait_item(item.id);
1945 if let hir::TraitItemKind::Fn(sig, _) = &item.kind {
1946 let abi = sig.header.abi;
1947 fn_maybe_err(tcx, item.ident.span, abi);
1951 hir::ItemKind::Struct(..) => {
1952 check_struct(tcx, it.hir_id, it.span);
1954 hir::ItemKind::Union(..) => {
1955 check_union(tcx, it.hir_id, it.span);
1957 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1958 let def_id = tcx.hir().local_def_id(it.hir_id);
1960 let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
1961 check_opaque(tcx, def_id, substs, it.span, &origin);
1963 hir::ItemKind::TyAlias(..) => {
1964 let def_id = tcx.hir().local_def_id(it.hir_id);
1965 let pty_ty = tcx.type_of(def_id);
1966 let generics = tcx.generics_of(def_id);
1967 check_type_params_are_used(tcx, &generics, pty_ty);
1969 hir::ItemKind::ForeignMod(ref m) => {
1970 check_abi(tcx, it.span, m.abi);
1972 if m.abi == Abi::RustIntrinsic {
1973 for item in m.items {
1974 intrinsic::check_intrinsic_type(tcx, item);
1976 } else if m.abi == Abi::PlatformIntrinsic {
1977 for item in m.items {
1978 intrinsic::check_platform_intrinsic_type(tcx, item);
1981 for item in m.items {
1982 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1983 let own_counts = generics.own_counts();
1984 if generics.params.len() - own_counts.lifetimes != 0 {
1985 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1986 (_, 0) => ("type", "types", Some("u32")),
1987 // We don't specify an example value, because we can't generate
1988 // a valid value for any type.
1989 (0, _) => ("const", "consts", None),
1990 _ => ("type or const", "types or consts", None),
1996 "foreign items may not have {} parameters",
1999 .span_label(item.span, &format!("can't have {} parameters", kinds))
2001 // FIXME: once we start storing spans for type arguments, turn this
2002 // into a suggestion.
2004 "replace the {} parameters with concrete {}{}",
2007 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
2013 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
2014 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
2019 _ => { /* nothing to do */ }
2023 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: LocalDefId, span: Span) {
2024 // Only restricted on wasm32 target for now
2025 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
2029 // If `#[link_section]` is missing, then nothing to verify
2030 let attrs = tcx.codegen_fn_attrs(id);
2031 if attrs.link_section.is_none() {
2035 // For the wasm32 target statics with `#[link_section]` are placed into custom
2036 // sections of the final output file, but this isn't link custom sections of
2037 // other executable formats. Namely we can only embed a list of bytes,
2038 // nothing with pointers to anything else or relocations. If any relocation
2039 // show up, reject them here.
2040 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
2041 // the consumer's responsibility to ensure all bytes that have been read
2042 // have defined values.
2043 match tcx.const_eval_poly(id.to_def_id()) {
2044 Ok(ConstValue::ByRef { alloc, .. }) => {
2045 if alloc.relocations().len() != 0 {
2046 let msg = "statics with a custom `#[link_section]` must be a \
2047 simple list of bytes on the wasm target with no \
2048 extra levels of indirection such as references";
2049 tcx.sess.span_err(span, msg);
2052 Ok(_) => bug!("Matching on non-ByRef static"),
2057 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
2058 let item_def_id = tcx.hir().local_def_id(item.hir_id);
2059 // an error would be reported if this fails.
2060 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id.to_def_id());
2063 fn report_forbidden_specialization(
2065 impl_item: &hir::ImplItem<'_>,
2068 let mut err = struct_span_err!(
2072 "`{}` specializes an item from a parent `impl`, but \
2073 that item is not marked `default`",
2076 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
2078 match tcx.span_of_impl(parent_impl) {
2080 err.span_label(span, "parent `impl` is here");
2082 "to specialize, `{}` in the parent `impl` must be marked `default`",
2087 err.note(&format!("parent implementation is in crate `{}`", cname));
2094 fn check_specialization_validity<'tcx>(
2096 trait_def: &ty::TraitDef,
2097 trait_item: &ty::AssocItem,
2099 impl_item: &hir::ImplItem<'_>,
2101 let kind = match impl_item.kind {
2102 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
2103 hir::ImplItemKind::Fn(..) => ty::AssocKind::Fn,
2104 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
2107 let ancestors = match trait_def.ancestors(tcx, impl_id) {
2108 Ok(ancestors) => ancestors,
2111 let mut ancestor_impls = ancestors
2113 .filter_map(|parent| {
2114 if parent.is_from_trait() {
2117 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
2122 if ancestor_impls.peek().is_none() {
2123 // No parent, nothing to specialize.
2127 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
2129 // Parent impl exists, and contains the parent item we're trying to specialize, but
2130 // doesn't mark it `default`.
2131 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
2132 Some(Err(parent_impl.def_id()))
2135 // Parent impl contains item and makes it specializable.
2136 Some(_) => Some(Ok(())),
2138 // Parent impl doesn't mention the item. This means it's inherited from the
2139 // grandparent. In that case, if parent is a `default impl`, inherited items use the
2140 // "defaultness" from the grandparent, else they are final.
2142 if tcx.impl_defaultness(parent_impl.def_id()).is_default() {
2145 Some(Err(parent_impl.def_id()))
2151 // If `opt_result` is `None`, we have only encountered `default impl`s that don't contain the
2152 // item. This is allowed, the item isn't actually getting specialized here.
2153 let result = opt_result.unwrap_or(Ok(()));
2155 if let Err(parent_impl) = result {
2156 report_forbidden_specialization(tcx, impl_item, parent_impl);
2160 fn check_impl_items_against_trait<'tcx>(
2162 full_impl_span: Span,
2163 impl_id: LocalDefId,
2164 impl_trait_ref: ty::TraitRef<'tcx>,
2165 impl_item_refs: &[hir::ImplItemRef<'_>],
2167 let impl_span = tcx.sess.source_map().guess_head_span(full_impl_span);
2169 // If the trait reference itself is erroneous (so the compilation is going
2170 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
2171 // isn't populated for such impls.
2172 if impl_trait_ref.references_error() {
2176 // Negative impls are not expected to have any items
2177 match tcx.impl_polarity(impl_id) {
2178 ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
2179 ty::ImplPolarity::Negative => {
2180 if let [first_item_ref, ..] = impl_item_refs {
2181 let first_item_span = tcx.hir().impl_item(first_item_ref.id).span;
2186 "negative impls cannot have any items"
2194 // Locate trait definition and items
2195 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
2197 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
2199 // Check existing impl methods to see if they are both present in trait
2200 // and compatible with trait signature
2201 for impl_item in impl_items() {
2202 let namespace = impl_item.kind.namespace();
2203 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
2204 let ty_trait_item = tcx
2205 .associated_items(impl_trait_ref.def_id)
2206 .find_by_name_and_namespace(tcx, ty_impl_item.ident, namespace, impl_trait_ref.def_id)
2208 // Not compatible, but needed for the error message
2209 tcx.associated_items(impl_trait_ref.def_id)
2210 .filter_by_name(tcx, ty_impl_item.ident, impl_trait_ref.def_id)
2214 // Check that impl definition matches trait definition
2215 if let Some(ty_trait_item) = ty_trait_item {
2216 match impl_item.kind {
2217 hir::ImplItemKind::Const(..) => {
2218 // Find associated const definition.
2219 if ty_trait_item.kind == ty::AssocKind::Const {
2228 let mut err = struct_span_err!(
2232 "item `{}` is an associated const, \
2233 which doesn't match its trait `{}`",
2235 impl_trait_ref.print_only_trait_path()
2237 err.span_label(impl_item.span, "does not match trait");
2238 // We can only get the spans from local trait definition
2239 // Same for E0324 and E0325
2240 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2241 err.span_label(trait_span, "item in trait");
2246 hir::ImplItemKind::Fn(..) => {
2247 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2248 if ty_trait_item.kind == ty::AssocKind::Fn {
2249 compare_impl_method(
2258 let mut err = struct_span_err!(
2262 "item `{}` is an associated method, \
2263 which doesn't match its trait `{}`",
2265 impl_trait_ref.print_only_trait_path()
2267 err.span_label(impl_item.span, "does not match trait");
2268 if let Some(trait_span) = opt_trait_span {
2269 err.span_label(trait_span, "item in trait");
2274 hir::ImplItemKind::TyAlias(_) => {
2275 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2276 if ty_trait_item.kind == ty::AssocKind::Type {
2286 let mut err = struct_span_err!(
2290 "item `{}` is an associated type, \
2291 which doesn't match its trait `{}`",
2293 impl_trait_ref.print_only_trait_path()
2295 err.span_label(impl_item.span, "does not match trait");
2296 if let Some(trait_span) = opt_trait_span {
2297 err.span_label(trait_span, "item in trait");
2304 check_specialization_validity(
2308 impl_id.to_def_id(),
2314 // Check for missing items from trait
2315 let mut missing_items = Vec::new();
2316 if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id.to_def_id()) {
2317 for trait_item in tcx.associated_items(impl_trait_ref.def_id).in_definition_order() {
2318 let is_implemented = ancestors
2319 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2320 .map(|node_item| !node_item.defining_node.is_from_trait())
2323 if !is_implemented && tcx.impl_defaultness(impl_id).is_final() {
2324 if !trait_item.defaultness.has_value() {
2325 missing_items.push(*trait_item);
2331 if !missing_items.is_empty() {
2332 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2336 fn missing_items_err(
2339 missing_items: &[ty::AssocItem],
2340 full_impl_span: Span,
2342 let missing_items_msg = missing_items
2344 .map(|trait_item| trait_item.ident.to_string())
2345 .collect::<Vec<_>>()
2348 let mut err = struct_span_err!(
2352 "not all trait items implemented, missing: `{}`",
2355 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2357 // `Span` before impl block closing brace.
2358 let hi = full_impl_span.hi() - BytePos(1);
2359 // Point at the place right before the closing brace of the relevant `impl` to suggest
2360 // adding the associated item at the end of its body.
2361 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2362 // Obtain the level of indentation ending in `sugg_sp`.
2363 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2364 // Make the whitespace that will make the suggestion have the right indentation.
2365 let padding: String = (0..indentation).map(|_| " ").collect();
2367 for trait_item in missing_items {
2368 let snippet = suggestion_signature(&trait_item, tcx);
2369 let code = format!("{}{}\n{}", padding, snippet, padding);
2370 let msg = format!("implement the missing item: `{}`", snippet);
2371 let appl = Applicability::HasPlaceholders;
2372 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2373 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2374 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2376 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2382 /// Resugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.
2383 fn bounds_from_generic_predicates(
2385 predicates: ty::GenericPredicates<'_>,
2386 ) -> (String, String) {
2387 let mut types: FxHashMap<Ty<'_>, Vec<DefId>> = FxHashMap::default();
2388 let mut projections = vec![];
2389 for (predicate, _) in predicates.predicates {
2390 debug!("predicate {:?}", predicate);
2391 match predicate.kind() {
2392 ty::PredicateKind::Trait(trait_predicate, _) => {
2393 let entry = types.entry(trait_predicate.skip_binder().self_ty()).or_default();
2394 let def_id = trait_predicate.skip_binder().def_id();
2395 if Some(def_id) != tcx.lang_items().sized_trait() {
2396 // Type params are `Sized` by default, do not add that restriction to the list
2397 // if it is a positive requirement.
2398 entry.push(trait_predicate.skip_binder().def_id());
2401 ty::PredicateKind::Projection(projection_pred) => {
2402 projections.push(projection_pred);
2407 let generics = if types.is_empty() {
2414 .filter_map(|t| match t.kind {
2415 ty::Param(_) => Some(t.to_string()),
2416 // Avoid suggesting the following:
2417 // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
2420 .collect::<Vec<_>>()
2424 let mut where_clauses = vec![];
2425 for (ty, bounds) in types {
2426 for bound in &bounds {
2427 where_clauses.push(format!("{}: {}", ty, tcx.def_path_str(*bound)));
2430 for projection in &projections {
2431 let p = projection.skip_binder();
2432 // FIXME: this is not currently supported syntax, we should be looking at the `types` and
2433 // insert the associated types where they correspond, but for now let's be "lazy" and
2434 // propose this instead of the following valid resugaring:
2435 // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
2436 where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.item_def_id), p.ty));
2438 let where_clauses = if where_clauses.is_empty() {
2441 format!(" where {}", where_clauses.join(", "))
2443 (generics, where_clauses)
2446 /// Return placeholder code for the given function.
2447 fn fn_sig_suggestion(
2451 predicates: ty::GenericPredicates<'_>,
2452 assoc: &ty::AssocItem,
2459 Some(match ty.kind {
2460 ty::Param(_) if assoc.fn_has_self_parameter && i == 0 => "self".to_string(),
2461 ty::Ref(reg, ref_ty, mutability) if i == 0 => {
2462 let reg = match &format!("{}", reg)[..] {
2463 "'_" | "" => String::new(),
2464 reg => format!("{} ", reg),
2466 if assoc.fn_has_self_parameter {
2468 ty::Param(param) if param.name == kw::SelfUpper => {
2469 format!("&{}{}self", reg, mutability.prefix_str())
2472 _ => format!("self: {}", ty),
2475 format!("_: {:?}", ty)
2479 if assoc.fn_has_self_parameter && i == 0 {
2480 format!("self: {:?}", ty)
2482 format!("_: {:?}", ty)
2487 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2488 .filter_map(|arg| arg)
2489 .collect::<Vec<String>>()
2491 let output = sig.output();
2492 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2494 let unsafety = sig.unsafety.prefix_str();
2495 let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
2497 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2498 // not be present in the `fn` definition, not will we account for renamed
2499 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2500 // fill in a significant portion of the missing code, and other subsequent
2501 // suggestions can help the user fix the code.
2503 "{}fn {}{}({}){}{} {{ todo!() }}",
2504 unsafety, ident, generics, args, output, where_clauses
2508 /// Return placeholder code for the given associated item.
2509 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2510 /// structured suggestion.
2511 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2513 ty::AssocKind::Fn => {
2514 // We skip the binder here because the binder would deanonymize all
2515 // late-bound regions, and we don't want method signatures to show up
2516 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2517 // regions just fine, showing `fn(&MyType)`.
2520 tcx.fn_sig(assoc.def_id).skip_binder(),
2522 tcx.predicates_of(assoc.def_id),
2526 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2527 ty::AssocKind::Const => {
2528 let ty = tcx.type_of(assoc.def_id);
2529 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2530 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2535 /// Checks whether a type can be represented in memory. In particular, it
2536 /// identifies types that contain themselves without indirection through a
2537 /// pointer, which would mean their size is unbounded.
2538 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: LocalDefId) -> bool {
2539 let rty = tcx.type_of(item_def_id);
2541 // Check that it is possible to represent this type. This call identifies
2542 // (1) types that contain themselves and (2) types that contain a different
2543 // recursive type. It is only necessary to throw an error on those that
2544 // contain themselves. For case 2, there must be an inner type that will be
2545 // caught by case 1.
2546 match rty.is_representable(tcx, sp) {
2547 Representability::SelfRecursive(spans) => {
2548 recursive_type_with_infinite_size_error(tcx, item_def_id.to_def_id(), spans);
2551 Representability::Representable | Representability::ContainsRecursive => (),
2556 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
2557 let t = tcx.type_of(def_id);
2558 if let ty::Adt(def, substs) = t.kind {
2559 if def.is_struct() {
2560 let fields = &def.non_enum_variant().fields;
2561 if fields.is_empty() {
2562 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2565 let e = fields[0].ty(tcx, substs);
2566 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2567 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2568 .span_label(sp, "SIMD elements must have the same type")
2573 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2574 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2580 "SIMD vector element type should be machine type"
2590 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: &ty::AdtDef) {
2591 let repr = def.repr;
2593 for attr in tcx.get_attrs(def.did).iter() {
2594 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2595 if let attr::ReprPacked(pack) = r {
2596 if let Some(repr_pack) = repr.pack {
2597 if pack as u64 != repr_pack.bytes() {
2602 "type has conflicting packed representation hints"
2610 if repr.align.is_some() {
2615 "type has conflicting packed and align representation hints"
2619 if let Some(def_spans) = check_packed_inner(tcx, def.did, &mut vec![]) {
2620 let mut err = struct_span_err!(
2624 "packed type cannot transitively contain a `#[repr(align)]` type"
2627 let hir = tcx.hir();
2628 let hir_id = hir.as_local_hir_id(def_spans[0].0.expect_local());
2629 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2631 tcx.def_span(def_spans[0].0),
2632 &format!("`{}` has a `#[repr(align)]` attribute", ident),
2636 if def_spans.len() > 2 {
2637 let mut first = true;
2638 for (adt_def, span) in def_spans.iter().skip(1).rev() {
2639 let hir_id = hir.as_local_hir_id(adt_def.expect_local());
2640 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2645 "`{}` contains a field of type `{}`",
2646 tcx.type_of(def.did),
2650 format!("...which contains a field of type `{}`", ident)
2664 fn check_packed_inner(
2667 stack: &mut Vec<DefId>,
2668 ) -> Option<Vec<(DefId, Span)>> {
2669 if let ty::Adt(def, substs) = tcx.type_of(def_id).kind {
2670 if def.is_struct() || def.is_union() {
2671 if def.repr.align.is_some() {
2672 return Some(vec![(def.did, DUMMY_SP)]);
2676 for field in &def.non_enum_variant().fields {
2677 if let ty::Adt(def, _) = field.ty(tcx, substs).kind {
2678 if !stack.contains(&def.did) {
2679 if let Some(mut defs) = check_packed_inner(tcx, def.did, stack) {
2680 defs.push((def.did, field.ident.span));
2693 /// Emit an error when encountering more or less than one variant in a transparent enum.
2694 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2695 let variant_spans: Vec<_> = adt
2698 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2700 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2701 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2702 err.span_label(sp, &msg);
2703 if let [start @ .., end] = &*variant_spans {
2704 for variant_span in start {
2705 err.span_label(*variant_span, "");
2707 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2712 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2714 fn bad_non_zero_sized_fields<'tcx>(
2716 adt: &'tcx ty::AdtDef,
2718 field_spans: impl Iterator<Item = Span>,
2721 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2722 let mut err = struct_span_err!(
2726 "{}transparent {} {}",
2727 if adt.is_enum() { "the variant of a " } else { "" },
2731 err.span_label(sp, &msg);
2732 for sp in field_spans {
2733 err.span_label(sp, "this field is non-zero-sized");
2738 fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, adt: &'tcx ty::AdtDef) {
2739 if !adt.repr.transparent() {
2742 let sp = tcx.sess.source_map().guess_head_span(sp);
2744 if adt.is_union() && !tcx.features().transparent_unions {
2746 &tcx.sess.parse_sess,
2747 sym::transparent_unions,
2749 "transparent unions are unstable",
2754 if adt.variants.len() != 1 {
2755 bad_variant_count(tcx, adt, sp, adt.did);
2756 if adt.variants.is_empty() {
2757 // Don't bother checking the fields. No variants (and thus no fields) exist.
2762 // For each field, figure out if it's known to be a ZST and align(1)
2763 let field_infos = adt.all_fields().map(|field| {
2764 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2765 let param_env = tcx.param_env(field.did);
2766 let layout = tcx.layout_of(param_env.and(ty));
2767 // We are currently checking the type this field came from, so it must be local
2768 let span = tcx.hir().span_if_local(field.did).unwrap();
2769 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2770 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2774 let non_zst_fields =
2775 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2776 let non_zst_count = non_zst_fields.clone().count();
2777 if non_zst_count != 1 {
2778 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2780 for (span, zst, align1) in field_infos {
2786 "zero-sized field in transparent {} has alignment larger than 1",
2789 .span_label(span, "has alignment larger than 1")
2795 #[allow(trivial_numeric_casts)]
2796 pub fn check_enum<'tcx>(
2799 vs: &'tcx [hir::Variant<'tcx>],
2802 let def_id = tcx.hir().local_def_id(id);
2803 let def = tcx.adt_def(def_id);
2804 def.destructor(tcx); // force the destructor to be evaluated
2807 let attributes = tcx.get_attrs(def_id.to_def_id());
2808 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2813 "unsupported representation for zero-variant enum"
2815 .span_label(sp, "zero-variant enum")
2820 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2821 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2822 if !tcx.features().repr128 {
2824 &tcx.sess.parse_sess,
2827 "repr with 128-bit type is unstable",
2834 if let Some(ref e) = v.disr_expr {
2835 tcx.ensure().typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2839 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2840 let is_unit = |var: &hir::Variant<'_>| match var.data {
2841 hir::VariantData::Unit(..) => true,
2845 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2846 let has_non_units = vs.iter().any(|var| !is_unit(var));
2847 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2848 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2850 if disr_non_unit || (disr_units && has_non_units) {
2852 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2857 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2858 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2859 // Check for duplicate discriminant values
2860 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2861 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2862 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did.expect_local());
2863 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2864 let i_span = match variant_i.disr_expr {
2865 Some(ref expr) => tcx.hir().span(expr.hir_id),
2866 None => tcx.hir().span(variant_i_hir_id),
2868 let span = match v.disr_expr {
2869 Some(ref expr) => tcx.hir().span(expr.hir_id),
2876 "discriminant value `{}` already exists",
2879 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2880 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2883 disr_vals.push(discr);
2886 check_representable(tcx, sp, def_id);
2887 check_transparent(tcx, sp, def);
2890 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
2895 "expected unit struct, unit variant or constant, found {}{}",
2897 tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`", s)),
2902 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2903 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2907 fn item_def_id(&self) -> Option<DefId> {
2911 fn default_constness_for_trait_bounds(&self) -> hir::Constness {
2912 // FIXME: refactor this into a method
2913 let node = self.tcx.hir().get(self.body_id);
2914 if let Some(fn_like) = FnLikeNode::from_node(node) {
2917 hir::Constness::NotConst
2921 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2923 let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local());
2924 let item_id = tcx.hir().ty_param_owner(hir_id);
2925 let item_def_id = tcx.hir().local_def_id(item_id);
2926 let generics = tcx.generics_of(item_def_id);
2927 let index = generics.param_def_id_to_index[&def_id];
2928 ty::GenericPredicates {
2930 predicates: tcx.arena.alloc_from_iter(
2931 self.param_env.caller_bounds().iter().filter_map(|predicate| {
2932 match predicate.kind() {
2933 ty::PredicateKind::Trait(ref data, _)
2934 if data.skip_binder().self_ty().is_param(index) =>
2936 // HACK(eddyb) should get the original `Span`.
2937 let span = tcx.def_span(def_id);
2938 Some((predicate, span))
2947 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2949 Some(def) => infer::EarlyBoundRegion(span, def.name),
2950 None => infer::MiscVariable(span),
2952 Some(self.next_region_var(v))
2955 fn allow_ty_infer(&self) -> bool {
2959 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2960 if let Some(param) = param {
2961 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2966 self.next_ty_var(TypeVariableOrigin {
2967 kind: TypeVariableOriginKind::TypeInference,
2976 param: Option<&ty::GenericParamDef>,
2978 ) -> &'tcx Const<'tcx> {
2979 if let Some(param) = param {
2980 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2985 self.next_const_var(
2987 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2992 fn projected_ty_from_poly_trait_ref(
2996 item_segment: &hir::PathSegment<'_>,
2997 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2999 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
3001 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
3005 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
3014 self.tcx().mk_projection(item_def_id, item_substs)
3017 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
3018 if ty.has_escaping_bound_vars() {
3019 ty // FIXME: normalization and escaping regions
3021 self.normalize_associated_types_in(span, &ty)
3025 fn set_tainted_by_errors(&self) {
3026 self.infcx.set_tainted_by_errors()
3029 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
3030 self.write_ty(hir_id, ty)
3034 /// Controls whether the arguments are tupled. This is used for the call
3037 /// Tupling means that all call-side arguments are packed into a tuple and
3038 /// passed as a single parameter. For example, if tupling is enabled, this
3041 /// fn f(x: (isize, isize))
3043 /// Can be called as:
3050 #[derive(Clone, Eq, PartialEq)]
3051 enum TupleArgumentsFlag {
3056 /// Controls how we perform fallback for unconstrained
3059 /// Do not fallback type variables to opaque types.
3061 /// Perform all possible kinds of fallback, including
3062 /// turning type variables to opaque types.
3066 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
3068 inh: &'a Inherited<'a, 'tcx>,
3069 param_env: ty::ParamEnv<'tcx>,
3070 body_id: hir::HirId,
3071 ) -> FnCtxt<'a, 'tcx> {
3075 err_count_on_creation: inh.tcx.sess.err_count(),
3077 ret_coercion_span: RefCell::new(None),
3078 resume_yield_tys: None,
3079 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
3080 diverges: Cell::new(Diverges::Maybe),
3081 has_errors: Cell::new(false),
3082 enclosing_breakables: RefCell::new(EnclosingBreakables {
3084 by_id: Default::default(),
3090 pub fn sess(&self) -> &Session {
3094 pub fn errors_reported_since_creation(&self) -> bool {
3095 self.tcx.sess.err_count() > self.err_count_on_creation
3098 /// Produces warning on the given node, if the current point in the
3099 /// function is unreachable, and there hasn't been another warning.
3100 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
3101 // FIXME: Combine these two 'if' expressions into one once
3102 // let chains are implemented
3103 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
3104 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
3105 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
3106 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
3107 if !span.is_desugaring(DesugaringKind::CondTemporary)
3108 && !span.is_desugaring(DesugaringKind::Async)
3109 && !orig_span.is_desugaring(DesugaringKind::Await)
3111 self.diverges.set(Diverges::WarnedAlways);
3113 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
3115 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, |lint| {
3116 let msg = format!("unreachable {}", kind);
3118 .span_label(span, &msg)
3122 .unwrap_or("any code following this expression is unreachable"),
3130 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
3131 ObligationCause::new(span, self.body_id, code)
3134 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
3135 self.cause(span, ObligationCauseCode::MiscObligation)
3138 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
3139 /// version (resolve_vars_if_possible), this version will
3140 /// also select obligations if it seems useful, in an effort
3141 /// to get more type information.
3142 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
3143 debug!("resolve_vars_with_obligations(ty={:?})", ty);
3145 // No Infer()? Nothing needs doing.
3146 if !ty.has_infer_types_or_consts() {
3147 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3151 // If `ty` is a type variable, see whether we already know what it is.
3152 ty = self.resolve_vars_if_possible(&ty);
3153 if !ty.has_infer_types_or_consts() {
3154 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3158 // If not, try resolving pending obligations as much as
3159 // possible. This can help substantially when there are
3160 // indirect dependencies that don't seem worth tracking
3162 self.select_obligations_where_possible(false, |_| {});
3163 ty = self.resolve_vars_if_possible(&ty);
3165 debug!("resolve_vars_with_obligations: ty={:?}", ty);
3169 fn record_deferred_call_resolution(
3171 closure_def_id: DefId,
3172 r: DeferredCallResolution<'tcx>,
3174 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3175 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
3178 fn remove_deferred_call_resolutions(
3180 closure_def_id: DefId,
3181 ) -> Vec<DeferredCallResolution<'tcx>> {
3182 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
3183 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
3186 pub fn tag(&self) -> String {
3187 format!("{:p}", self)
3190 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
3191 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
3192 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
3197 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
3199 "write_ty({:?}, {:?}) in fcx {}",
3201 self.resolve_vars_if_possible(&ty),
3204 self.tables.borrow_mut().node_types_mut().insert(id, ty);
3206 if ty.references_error() {
3207 self.has_errors.set(true);
3208 self.set_tainted_by_errors();
3212 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
3213 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
3216 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
3217 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
3220 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
3221 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
3222 self.write_resolution(hir_id, Ok((DefKind::AssocFn, method.def_id)));
3223 self.write_substs(hir_id, method.substs);
3225 // When the method is confirmed, the `method.substs` includes
3226 // parameters from not just the method, but also the impl of
3227 // the method -- in particular, the `Self` type will be fully
3228 // resolved. However, those are not something that the "user
3229 // specified" -- i.e., those types come from the inferred type
3230 // of the receiver, not something the user wrote. So when we
3231 // create the user-substs, we want to replace those earlier
3232 // types with just the types that the user actually wrote --
3233 // that is, those that appear on the *method itself*.
3235 // As an example, if the user wrote something like
3236 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
3237 // type of `foo` (possibly adjusted), but we don't want to
3238 // include that. We want just the `[_, u32]` part.
3239 if !method.substs.is_noop() {
3240 let method_generics = self.tcx.generics_of(method.def_id);
3241 if !method_generics.params.is_empty() {
3242 let user_type_annotation = self.infcx.probe(|_| {
3243 let user_substs = UserSubsts {
3244 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
3245 let i = param.index as usize;
3246 if i < method_generics.parent_count {
3247 self.infcx.var_for_def(DUMMY_SP, param)
3252 user_self_ty: None, // not relevant here
3255 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3261 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
3262 self.write_user_type_annotation(hir_id, user_type_annotation);
3267 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
3268 if !substs.is_noop() {
3269 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
3271 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
3275 /// Given the substs that we just converted from the HIR, try to
3276 /// canonicalize them and store them as user-given substitutions
3277 /// (i.e., substitutions that must be respected by the NLL check).
3279 /// This should be invoked **before any unifications have
3280 /// occurred**, so that annotations like `Vec<_>` are preserved
3282 pub fn write_user_type_annotation_from_substs(
3286 substs: SubstsRef<'tcx>,
3287 user_self_ty: Option<UserSelfTy<'tcx>>,
3290 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
3291 user_self_ty={:?} in fcx {}",
3299 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
3300 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
3302 UserSubsts { substs, user_self_ty },
3304 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
3305 self.write_user_type_annotation(hir_id, canonicalized);
3309 pub fn write_user_type_annotation(
3312 canonical_user_type_annotation: CanonicalUserType<'tcx>,
3315 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
3317 canonical_user_type_annotation,
3321 if !canonical_user_type_annotation.is_identity() {
3324 .user_provided_types_mut()
3325 .insert(hir_id, canonical_user_type_annotation);
3327 debug!("write_user_type_annotation: skipping identity substs");
3331 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
3332 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
3338 let autoborrow_mut = adj.iter().any(|adj| {
3339 matches!(adj, &Adjustment {
3340 kind: Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })),
3345 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
3346 Entry::Vacant(entry) => {
3349 Entry::Occupied(mut entry) => {
3350 debug!(" - composing on top of {:?}", entry.get());
3351 match (&entry.get()[..], &adj[..]) {
3352 // Applying any adjustment on top of a NeverToAny
3353 // is a valid NeverToAny adjustment, because it can't
3355 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3357 Adjustment { kind: Adjust::Deref(_), .. },
3358 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3360 Adjustment { kind: Adjust::Deref(_), .. },
3361 .. // Any following adjustments are allowed.
3363 // A reborrow has no effect before a dereference.
3365 // FIXME: currently we never try to compose autoderefs
3366 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3368 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3369 expr, entry.get(), adj)
3371 *entry.get_mut() = adj;
3375 // If there is an mutable auto-borrow, it is equivalent to `&mut <expr>`.
3376 // In this case implicit use of `Deref` and `Index` within `<expr>` should
3377 // instead be `DerefMut` and `IndexMut`, so fix those up.
3379 self.convert_place_derefs_to_mutable(expr);
3383 /// Basically whenever we are converting from a type scheme into
3384 /// the fn body space, we always want to normalize associated
3385 /// types as well. This function combines the two.
3386 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3388 T: TypeFoldable<'tcx>,
3390 let value = value.subst(self.tcx, substs);
3391 let result = self.normalize_associated_types_in(span, &value);
3392 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3396 /// As `instantiate_type_scheme`, but for the bounds found in a
3397 /// generic type scheme.
3398 fn instantiate_bounds(
3402 substs: SubstsRef<'tcx>,
3403 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3404 let bounds = self.tcx.predicates_of(def_id);
3405 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3406 let result = bounds.instantiate(self.tcx, substs);
3407 let result = self.normalize_associated_types_in(span, &result);
3409 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3410 bounds, substs, result, spans,
3415 /// Replaces the opaque types from the given value with type variables,
3416 /// and records the `OpaqueTypeMap` for later use during writeback. See
3417 /// `InferCtxt::instantiate_opaque_types` for more details.
3418 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3420 parent_id: hir::HirId,
3424 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3426 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3427 parent_def_id, value
3430 let (value, opaque_type_map) =
3431 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3439 let mut opaque_types = self.opaque_types.borrow_mut();
3440 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3441 for (ty, decl) in opaque_type_map {
3442 let _ = opaque_types.insert(ty, decl);
3443 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3449 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3451 T: TypeFoldable<'tcx>,
3453 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3456 fn normalize_associated_types_in_as_infer_ok<T>(
3460 ) -> InferOk<'tcx, T>
3462 T: TypeFoldable<'tcx>,
3464 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3467 pub fn require_type_meets(
3471 code: traits::ObligationCauseCode<'tcx>,
3474 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3477 pub fn require_type_is_sized(
3481 code: traits::ObligationCauseCode<'tcx>,
3483 if !ty.references_error() {
3484 let lang_item = self.tcx.require_lang_item(SizedTraitLangItem, None);
3485 self.require_type_meets(ty, span, code, lang_item);
3489 pub fn require_type_is_sized_deferred(
3493 code: traits::ObligationCauseCode<'tcx>,
3495 if !ty.references_error() {
3496 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3500 pub fn register_bound(
3504 cause: traits::ObligationCause<'tcx>,
3506 if !ty.references_error() {
3507 self.fulfillment_cx.borrow_mut().register_bound(
3517 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3518 let t = AstConv::ast_ty_to_ty(self, ast_t);
3519 self.register_wf_obligation(t.into(), ast_t.span, traits::MiscObligation);
3523 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3524 let ty = self.to_ty(ast_ty);
3525 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3527 if Self::can_contain_user_lifetime_bounds(ty) {
3528 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3529 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3530 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3536 pub fn to_const(&self, ast_c: &hir::AnonConst) -> &'tcx ty::Const<'tcx> {
3537 let const_def_id = self.tcx.hir().local_def_id(ast_c.hir_id);
3538 let c = ty::Const::from_anon_const(self.tcx, const_def_id);
3539 self.register_wf_obligation(
3541 self.tcx.hir().span(ast_c.hir_id),
3542 ObligationCauseCode::MiscObligation,
3547 // If the type given by the user has free regions, save it for later, since
3548 // NLL would like to enforce those. Also pass in types that involve
3549 // projections, since those can resolve to `'static` bounds (modulo #54940,
3550 // which hopefully will be fixed by the time you see this comment, dear
3551 // reader, although I have my doubts). Also pass in types with inference
3552 // types, because they may be repeated. Other sorts of things are already
3553 // sufficiently enforced with erased regions. =)
3554 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3556 T: TypeFoldable<'tcx>,
3558 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3561 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3562 match self.tables.borrow().node_types().get(id) {
3564 None if self.is_tainted_by_errors() => self.tcx.ty_error(),
3567 "no type for node {}: {} in fcx {}",
3569 self.tcx.hir().node_to_string(id),
3576 /// Registers an obligation for checking later, during regionck, that `arg` is well-formed.
3577 pub fn register_wf_obligation(
3579 arg: subst::GenericArg<'tcx>,
3581 code: traits::ObligationCauseCode<'tcx>,
3583 // WF obligations never themselves fail, so no real need to give a detailed cause:
3584 let cause = traits::ObligationCause::new(span, self.body_id, code);
3585 self.register_predicate(traits::Obligation::new(
3588 ty::PredicateKind::WellFormed(arg).to_predicate(self.tcx),
3592 /// Registers obligations that all `substs` are well-formed.
3593 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3594 for arg in substs.iter().filter(|arg| {
3595 matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
3597 self.register_wf_obligation(arg, expr.span, traits::MiscObligation);
3601 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3602 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3603 /// trait/region obligations.
3605 /// For example, if there is a function:
3608 /// fn foo<'a,T:'a>(...)
3611 /// and a reference:
3617 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3618 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3619 pub fn add_obligations_for_parameters(
3621 cause: traits::ObligationCause<'tcx>,
3622 predicates: ty::InstantiatedPredicates<'tcx>,
3624 assert!(!predicates.has_escaping_bound_vars());
3626 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3628 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3629 self.register_predicate(obligation);
3633 // FIXME(arielb1): use this instead of field.ty everywhere
3634 // Only for fields! Returns <none> for methods>
3635 // Indifferent to privacy flags
3639 field: &'tcx ty::FieldDef,
3640 substs: SubstsRef<'tcx>,
3642 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3645 fn check_casts(&self) {
3646 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3647 for cast in deferred_cast_checks.drain(..) {
3652 fn resolve_generator_interiors(&self, def_id: DefId) {
3653 let mut generators = self.deferred_generator_interiors.borrow_mut();
3654 for (body_id, interior, kind) in generators.drain(..) {
3655 self.select_obligations_where_possible(false, |_| {});
3656 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3660 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3662 // - Unconstrained ints are replaced with `i32`.
3664 // - Unconstrained floats are replaced with with `f64`.
3666 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3667 // is enabled. Otherwise, they are replaced with `()`.
3669 // Fallback becomes very dubious if we have encountered type-checking errors.
3670 // In that case, fallback to Error.
3671 // The return value indicates whether fallback has occurred.
3672 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3673 use rustc_middle::ty::error::UnconstrainedNumeric::Neither;
3674 use rustc_middle::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3676 assert!(ty.is_ty_infer());
3677 let fallback = match self.type_is_unconstrained_numeric(ty) {
3678 _ if self.is_tainted_by_errors() => self.tcx().ty_error(),
3679 UnconstrainedInt => self.tcx.types.i32,
3680 UnconstrainedFloat => self.tcx.types.f64,
3681 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3683 // This type variable was created from the instantiation of an opaque
3684 // type. The fact that we're attempting to perform fallback for it
3685 // means that the function neither constrained it to a concrete
3686 // type, nor to the opaque type itself.
3688 // For example, in this code:
3691 // type MyType = impl Copy;
3692 // fn defining_use() -> MyType { true }
3693 // fn other_use() -> MyType { defining_use() }
3696 // `defining_use` will constrain the instantiated inference
3697 // variable to `bool`, while `other_use` will constrain
3698 // the instantiated inference variable to `MyType`.
3700 // When we process opaque types during writeback, we
3701 // will handle cases like `other_use`, and not count
3702 // them as defining usages
3704 // However, we also need to handle cases like this:
3707 // pub type Foo = impl Copy;
3708 // fn produce() -> Option<Foo> {
3713 // In the above snippet, the inference variable created by
3714 // instantiating `Option<Foo>` will be completely unconstrained.
3715 // We treat this as a non-defining use by making the inference
3716 // variable fall back to the opaque type itself.
3717 if let FallbackMode::All = mode {
3718 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3720 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3732 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3733 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3737 fn select_all_obligations_or_error(&self) {
3738 debug!("select_all_obligations_or_error");
3739 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3740 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3744 /// Select as many obligations as we can at present.
3745 fn select_obligations_where_possible(
3747 fallback_has_occurred: bool,
3748 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3750 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3751 if let Err(mut errors) = result {
3752 mutate_fullfillment_errors(&mut errors);
3753 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3757 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3758 /// returns a type of `&T`, but the actual type we assign to the
3759 /// *expression* is `T`. So this function just peels off the return
3760 /// type by one layer to yield `T`.
3761 fn make_overloaded_place_return_type(
3763 method: MethodCallee<'tcx>,
3764 ) -> ty::TypeAndMut<'tcx> {
3765 // extract method return type, which will be &T;
3766 let ret_ty = method.sig.output();
3768 // method returns &T, but the type as visible to user is T, so deref
3769 ret_ty.builtin_deref(true).unwrap()
3772 fn check_method_argument_types(
3775 expr: &'tcx hir::Expr<'tcx>,
3776 method: Result<MethodCallee<'tcx>, ()>,
3777 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3778 tuple_arguments: TupleArgumentsFlag,
3779 expected: Expectation<'tcx>,
3781 let has_error = match method {
3782 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3786 let err_inputs = self.err_args(args_no_rcvr.len());
3788 let err_inputs = match tuple_arguments {
3789 DontTupleArguments => err_inputs,
3790 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3793 self.check_argument_types(
3803 return self.tcx.ty_error();
3806 let method = method.unwrap();
3807 // HACK(eddyb) ignore self in the definition (see above).
3808 let expected_arg_tys = self.expected_inputs_for_expected_output(
3811 method.sig.output(),
3812 &method.sig.inputs()[1..],
3814 self.check_argument_types(
3817 &method.sig.inputs()[1..],
3818 &expected_arg_tys[..],
3820 method.sig.c_variadic,
3822 self.tcx.hir().span_if_local(method.def_id),
3827 fn self_type_matches_expected_vid(
3829 trait_ref: ty::PolyTraitRef<'tcx>,
3830 expected_vid: ty::TyVid,
3832 let self_ty = self.shallow_resolve(trait_ref.skip_binder().self_ty());
3834 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3835 trait_ref, self_ty, expected_vid
3837 match self_ty.kind {
3838 ty::Infer(ty::TyVar(found_vid)) => {
3839 // FIXME: consider using `sub_root_var` here so we
3840 // can see through subtyping.
3841 let found_vid = self.root_var(found_vid);
3842 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3843 expected_vid == found_vid
3849 fn obligations_for_self_ty<'b>(
3852 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3855 // FIXME: consider using `sub_root_var` here so we
3856 // can see through subtyping.
3857 let ty_var_root = self.root_var(self_ty);
3859 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3862 self.fulfillment_cx.borrow().pending_obligations()
3867 .pending_obligations()
3869 .filter_map(move |obligation| match obligation.predicate.kind() {
3870 ty::PredicateKind::Projection(ref data) => {
3871 Some((data.to_poly_trait_ref(self.tcx), obligation))
3873 ty::PredicateKind::Trait(ref data, _) => {
3874 Some((data.to_poly_trait_ref(), obligation))
3876 ty::PredicateKind::Subtype(..) => None,
3877 ty::PredicateKind::RegionOutlives(..) => None,
3878 ty::PredicateKind::TypeOutlives(..) => None,
3879 ty::PredicateKind::WellFormed(..) => None,
3880 ty::PredicateKind::ObjectSafe(..) => None,
3881 ty::PredicateKind::ConstEvaluatable(..) => None,
3882 ty::PredicateKind::ConstEquate(..) => None,
3883 // N.B., this predicate is created by breaking down a
3884 // `ClosureType: FnFoo()` predicate, where
3885 // `ClosureType` represents some `Closure`. It can't
3886 // possibly be referring to the current closure,
3887 // because we haven't produced the `Closure` for
3888 // this closure yet; this is exactly why the other
3889 // code is looking for a self type of a unresolved
3890 // inference variable.
3891 ty::PredicateKind::ClosureKind(..) => None,
3893 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3896 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3897 self.obligations_for_self_ty(self_ty)
3898 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3901 /// Generic function that factors out common logic from function calls,
3902 /// method calls and overloaded operators.
3903 fn check_argument_types(
3906 expr: &'tcx hir::Expr<'tcx>,
3907 fn_inputs: &[Ty<'tcx>],
3908 expected_arg_tys: &[Ty<'tcx>],
3909 args: &'tcx [hir::Expr<'tcx>],
3911 tuple_arguments: TupleArgumentsFlag,
3912 def_span: Option<Span>,
3915 // Grab the argument types, supplying fresh type variables
3916 // if the wrong number of arguments were supplied
3917 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3919 // All the input types from the fn signature must outlive the call
3920 // so as to validate implied bounds.
3921 for (&fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3922 self.register_wf_obligation(fn_input_ty.into(), arg_expr.span, traits::MiscObligation);
3925 let expected_arg_count = fn_inputs.len();
3927 let param_count_error = |expected_count: usize,
3932 let (span, start_span, args) = match &expr.kind {
3933 hir::ExprKind::Call(hir::Expr { span, .. }, args) => (*span, *span, &args[..]),
3934 hir::ExprKind::MethodCall(path_segment, span, args, _) => (
3936 // `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
3939 .and_then(|args| args.args.iter().last())
3940 // Account for `foo.bar::<T>()`.
3942 // Skip the closing `>`.
3945 .next_point(tcx.sess.source_map().next_point(arg.span()))
3948 &args[1..], // Skip the receiver.
3950 k => span_bug!(sp, "checking argument types on a non-call: `{:?}`", k),
3952 let arg_spans = if args.is_empty() {
3954 // ^^^-- supplied 0 arguments
3956 // expected 2 arguments
3957 vec![tcx.sess.source_map().next_point(start_span).with_hi(sp.hi())]
3960 // ^^^ - - - supplied 3 arguments
3962 // expected 2 arguments
3963 args.iter().map(|arg| arg.span).collect::<Vec<Span>>()
3966 let mut err = tcx.sess.struct_span_err_with_code(
3969 "this function takes {}{} but {} {} supplied",
3970 if c_variadic { "at least " } else { "" },
3971 potentially_plural_count(expected_count, "argument"),
3972 potentially_plural_count(arg_count, "argument"),
3973 if arg_count == 1 { "was" } else { "were" }
3975 DiagnosticId::Error(error_code.to_owned()),
3977 let label = format!("supplied {}", potentially_plural_count(arg_count, "argument"));
3978 for (i, span) in arg_spans.into_iter().enumerate() {
3981 if arg_count == 0 || i + 1 == arg_count { &label } else { "" },
3985 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().guess_head_span(sp)) {
3986 err.span_label(def_s, "defined here");
3989 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3990 // remove closing `)` from the span
3991 let sugg_span = sugg_span.shrink_to_lo();
3992 err.span_suggestion(
3994 "expected the unit value `()`; create it with empty parentheses",
3996 Applicability::MachineApplicable,
4003 if c_variadic { "at least " } else { "" },
4004 potentially_plural_count(expected_count, "argument")
4011 let mut expected_arg_tys = expected_arg_tys.to_vec();
4013 let formal_tys = if tuple_arguments == TupleArguments {
4014 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
4015 match tuple_type.kind {
4016 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
4017 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
4018 expected_arg_tys = vec![];
4019 self.err_args(args.len())
4021 ty::Tuple(arg_types) => {
4022 expected_arg_tys = match expected_arg_tys.get(0) {
4023 Some(&ty) => match ty.kind {
4024 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
4029 arg_types.iter().map(|k| k.expect_ty()).collect()
4036 "cannot use call notation; the first type parameter \
4037 for the function trait is neither a tuple nor unit"
4040 expected_arg_tys = vec![];
4041 self.err_args(args.len())
4044 } else if expected_arg_count == supplied_arg_count {
4046 } else if c_variadic {
4047 if supplied_arg_count >= expected_arg_count {
4050 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
4051 expected_arg_tys = vec![];
4052 self.err_args(supplied_arg_count)
4055 // is the missing argument of type `()`?
4056 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
4057 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
4058 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
4059 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
4063 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
4065 expected_arg_tys = vec![];
4066 self.err_args(supplied_arg_count)
4070 "check_argument_types: formal_tys={:?}",
4071 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
4074 // If there is no expectation, expect formal_tys.
4075 let expected_arg_tys =
4076 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
4078 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
4080 // Check the arguments.
4081 // We do this in a pretty awful way: first we type-check any arguments
4082 // that are not closures, then we type-check the closures. This is so
4083 // that we have more information about the types of arguments when we
4084 // type-check the functions. This isn't really the right way to do this.
4085 for &check_closures in &[false, true] {
4086 debug!("check_closures={}", check_closures);
4088 // More awful hacks: before we check argument types, try to do
4089 // an "opportunistic" trait resolution of any trait bounds on
4090 // the call. This helps coercions.
4092 self.select_obligations_where_possible(false, |errors| {
4093 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
4094 self.point_at_arg_instead_of_call_if_possible(
4096 &final_arg_types[..],
4103 // For C-variadic functions, we don't have a declared type for all of
4104 // the arguments hence we only do our usual type checking with
4105 // the arguments who's types we do know.
4106 let t = if c_variadic {
4108 } else if tuple_arguments == TupleArguments {
4113 for (i, arg) in args.iter().take(t).enumerate() {
4114 // Warn only for the first loop (the "no closures" one).
4115 // Closure arguments themselves can't be diverging, but
4116 // a previous argument can, e.g., `foo(panic!(), || {})`.
4117 if !check_closures {
4118 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
4121 let is_closure = match arg.kind {
4122 ExprKind::Closure(..) => true,
4126 if is_closure != check_closures {
4130 debug!("checking the argument");
4131 let formal_ty = formal_tys[i];
4133 // The special-cased logic below has three functions:
4134 // 1. Provide as good of an expected type as possible.
4135 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
4137 let checked_ty = self.check_expr_with_expectation(&arg, expected);
4139 // 2. Coerce to the most detailed type that could be coerced
4140 // to, which is `expected_ty` if `rvalue_hint` returns an
4141 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
4142 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
4143 // We're processing function arguments so we definitely want to use
4144 // two-phase borrows.
4145 self.demand_coerce(&arg, checked_ty, coerce_ty, None, AllowTwoPhase::Yes);
4146 final_arg_types.push((i, checked_ty, coerce_ty));
4148 // 3. Relate the expected type and the formal one,
4149 // if the expected type was used for the coercion.
4150 self.demand_suptype(arg.span, formal_ty, coerce_ty);
4154 // We also need to make sure we at least write the ty of the other
4155 // arguments which we skipped above.
4157 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
4158 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
4159 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
4162 for arg in args.iter().skip(expected_arg_count) {
4163 let arg_ty = self.check_expr(&arg);
4165 // There are a few types which get autopromoted when passed via varargs
4166 // in C but we just error out instead and require explicit casts.
4167 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
4169 ty::Float(ast::FloatTy::F32) => {
4170 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
4172 ty::Int(ast::IntTy::I8 | ast::IntTy::I16) | ty::Bool => {
4173 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
4175 ty::Uint(ast::UintTy::U8 | ast::UintTy::U16) => {
4176 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
4179 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
4180 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
4181 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
4189 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
4190 vec![self.tcx.ty_error(); len]
4193 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
4194 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
4195 /// reference a type argument. The reason to walk also the checked type is that the coerced type
4196 /// can be not easily comparable with predicate type (because of coercion). If the types match
4197 /// for either checked or coerced type, and there's only *one* argument that does, we point at
4198 /// the corresponding argument's expression span instead of the `fn` call path span.
4199 fn point_at_arg_instead_of_call_if_possible(
4201 errors: &mut Vec<traits::FulfillmentError<'_>>,
4202 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
4204 args: &'tcx [hir::Expr<'tcx>],
4206 // We *do not* do this for desugared call spans to keep good diagnostics when involving
4207 // the `?` operator.
4208 if call_sp.desugaring_kind().is_some() {
4212 for error in errors {
4213 // Only if the cause is somewhere inside the expression we want try to point at arg.
4214 // Otherwise, it means that the cause is somewhere else and we should not change
4215 // anything because we can break the correct span.
4216 if !call_sp.contains(error.obligation.cause.span) {
4220 if let ty::PredicateKind::Trait(predicate, _) = error.obligation.predicate.kind() {
4221 // Collect the argument position for all arguments that could have caused this
4222 // `FulfillmentError`.
4223 let mut referenced_in = final_arg_types
4225 .map(|&(i, checked_ty, _)| (i, checked_ty))
4226 .chain(final_arg_types.iter().map(|&(i, _, coerced_ty)| (i, coerced_ty)))
4227 .flat_map(|(i, ty)| {
4228 let ty = self.resolve_vars_if_possible(&ty);
4229 // We walk the argument type because the argument's type could have
4230 // been `Option<T>`, but the `FulfillmentError` references `T`.
4231 if ty.walk().any(|arg| arg == predicate.skip_binder().self_ty().into()) {
4237 .collect::<Vec<_>>();
4239 // Both checked and coerced types could have matched, thus we need to remove
4241 referenced_in.sort();
4242 referenced_in.dedup();
4244 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
4245 // We make sure that only *one* argument matches the obligation failure
4246 // and we assign the obligation's span to its expression's.
4247 error.obligation.cause.make_mut().span = args[ref_in].span;
4248 error.points_at_arg_span = true;
4254 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4255 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4256 /// were caused by them. If they were, we point at the corresponding type argument's span
4257 /// instead of the `fn` call path span.
4258 fn point_at_type_arg_instead_of_call_if_possible(
4260 errors: &mut Vec<traits::FulfillmentError<'_>>,
4261 call_expr: &'tcx hir::Expr<'tcx>,
4263 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4264 if let hir::ExprKind::Path(qpath) = &path.kind {
4265 if let hir::QPath::Resolved(_, path) = &qpath {
4266 for error in errors {
4267 if let ty::PredicateKind::Trait(predicate, _) =
4268 error.obligation.predicate.kind()
4270 // If any of the type arguments in this path segment caused the
4271 // `FullfillmentError`, point at its span (#61860).
4275 .filter_map(|seg| seg.args.as_ref())
4276 .flat_map(|a| a.args.iter())
4278 if let hir::GenericArg::Type(hir_ty) = &arg {
4279 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4282 // Avoid ICE with associated types. As this is best
4283 // effort only, it's ok to ignore the case. It
4284 // would trigger in `is_send::<T::AssocType>();`
4285 // from `typeck-default-trait-impl-assoc-type.rs`.
4287 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4288 let ty = self.resolve_vars_if_possible(&ty);
4289 if ty == predicate.skip_binder().self_ty() {
4290 error.obligation.cause.make_mut().span = hir_ty.span;
4302 // AST fragment checking
4303 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4307 ast::LitKind::Str(..) => tcx.mk_static_str(),
4308 ast::LitKind::ByteStr(ref v) => {
4309 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4311 ast::LitKind::Byte(_) => tcx.types.u8,
4312 ast::LitKind::Char(_) => tcx.types.char,
4313 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4314 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4315 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4316 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4317 ty::Int(_) | ty::Uint(_) => Some(ty),
4318 ty::Char => Some(tcx.types.u8),
4319 ty::RawPtr(..) => Some(tcx.types.usize),
4320 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4323 opt_ty.unwrap_or_else(|| self.next_int_var())
4325 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4326 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4327 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4328 ty::Float(_) => Some(ty),
4331 opt_ty.unwrap_or_else(|| self.next_float_var())
4333 ast::LitKind::Bool(_) => tcx.types.bool,
4334 ast::LitKind::Err(_) => tcx.ty_error(),
4338 /// Unifies the output type with the expected type early, for more coercions
4339 /// and forward type information on the input expressions.
4340 fn expected_inputs_for_expected_output(
4343 expected_ret: Expectation<'tcx>,
4344 formal_ret: Ty<'tcx>,
4345 formal_args: &[Ty<'tcx>],
4346 ) -> Vec<Ty<'tcx>> {
4347 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4348 let ret_ty = match expected_ret.only_has_type(self) {
4350 None => return Vec::new(),
4352 let expect_args = self
4353 .fudge_inference_if_ok(|| {
4354 // Attempt to apply a subtyping relationship between the formal
4355 // return type (likely containing type variables if the function
4356 // is polymorphic) and the expected return type.
4357 // No argument expectations are produced if unification fails.
4358 let origin = self.misc(call_span);
4359 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4361 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4362 // to identity so the resulting type is not constrained.
4365 // Process any obligations locally as much as
4366 // we can. We don't care if some things turn
4367 // out unconstrained or ambiguous, as we're
4368 // just trying to get hints here.
4369 self.save_and_restore_in_snapshot_flag(|_| {
4370 let mut fulfill = TraitEngine::new(self.tcx);
4371 for obligation in ok.obligations {
4372 fulfill.register_predicate_obligation(self, obligation);
4374 fulfill.select_where_possible(self)
4378 Err(_) => return Err(()),
4381 // Record all the argument types, with the substitutions
4382 // produced from the above subtyping unification.
4383 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4385 .unwrap_or_default();
4387 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4388 formal_args, formal_ret, expect_args, expected_ret
4393 pub fn check_struct_path(
4397 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4398 let path_span = match *qpath {
4399 QPath::Resolved(_, ref path) => path.span,
4400 QPath::TypeRelative(ref qself, _) => qself.span,
4402 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4403 let variant = match def {
4405 self.set_tainted_by_errors();
4408 Res::Def(DefKind::Variant, _) => match ty.kind {
4409 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4410 _ => bug!("unexpected type: {:?}", ty),
4412 Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
4413 | Res::SelfTy(..) => match ty.kind {
4414 ty::Adt(adt, substs) if !adt.is_enum() => {
4415 Some((adt.non_enum_variant(), adt.did, substs))
4419 _ => bug!("unexpected definition: {:?}", def),
4422 if let Some((variant, did, substs)) = variant {
4423 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4424 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4426 // Check bounds on type arguments used in the path.
4427 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4429 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4430 self.add_obligations_for_parameters(cause, bounds);
4438 "expected struct, variant or union type, found {}",
4439 ty.sort_string(self.tcx)
4441 .span_label(path_span, "not a struct")
4447 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4448 // The newly resolved definition is written into `type_dependent_defs`.
4449 fn finish_resolving_struct_path(
4454 ) -> (Res, Ty<'tcx>) {
4456 QPath::Resolved(ref maybe_qself, ref path) => {
4457 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4458 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4461 QPath::TypeRelative(ref qself, ref segment) => {
4462 let ty = self.to_ty(qself);
4464 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4470 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4471 let ty = result.map(|(ty, _, _)| ty).unwrap_or_else(|_| self.tcx().ty_error());
4472 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4474 // Write back the new resolution.
4475 self.write_resolution(hir_id, result);
4477 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4482 /// Resolves an associated value path into a base type and associated constant, or method
4483 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4484 pub fn resolve_ty_and_res_ufcs<'b>(
4486 qpath: &'b QPath<'b>,
4489 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4490 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4491 let (ty, qself, item_segment) = match *qpath {
4492 QPath::Resolved(ref opt_qself, ref path) => {
4495 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4499 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4501 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4502 // Return directly on cache hit. This is useful to avoid doubly reporting
4503 // errors with default match binding modes. See #44614.
4505 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4506 return (def, Some(ty), slice::from_ref(&**item_segment));
4508 let item_name = item_segment.ident;
4509 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4510 let result = match error {
4511 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4512 _ => Err(ErrorReported),
4514 if item_name.name != kw::Invalid {
4515 if let Some(mut e) = self.report_method_error(
4519 SelfSource::QPath(qself),
4529 // Write back the new resolution.
4530 self.write_resolution(hir_id, result);
4532 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4534 slice::from_ref(&**item_segment),
4538 pub fn check_decl_initializer(
4540 local: &'tcx hir::Local<'tcx>,
4541 init: &'tcx hir::Expr<'tcx>,
4543 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4544 // for #42640 (default match binding modes).
4547 let ref_bindings = local.pat.contains_explicit_ref_binding();
4549 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4550 if let Some(m) = ref_bindings {
4551 // Somewhat subtle: if we have a `ref` binding in the pattern,
4552 // we want to avoid introducing coercions for the RHS. This is
4553 // both because it helps preserve sanity and, in the case of
4554 // ref mut, for soundness (issue #23116). In particular, in
4555 // the latter case, we need to be clear that the type of the
4556 // referent for the reference that results is *equal to* the
4557 // type of the place it is referencing, and not some
4558 // supertype thereof.
4559 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4560 self.demand_eqtype(init.span, local_ty, init_ty);
4563 self.check_expr_coercable_to_type(init, local_ty, None)
4567 /// Type check a `let` statement.
4568 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4569 // Determine and write the type which we'll check the pattern against.
4570 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4571 self.write_ty(local.hir_id, ty);
4573 // Type check the initializer.
4574 if let Some(ref init) = local.init {
4575 let init_ty = self.check_decl_initializer(local, &init);
4576 self.overwrite_local_ty_if_err(local, ty, init_ty);
4579 // Does the expected pattern type originate from an expression and what is the span?
4580 let (origin_expr, ty_span) = match (local.ty, local.init) {
4581 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4582 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4583 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4586 // Type check the pattern. Override if necessary to avoid knock-on errors.
4587 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4588 let pat_ty = self.node_ty(local.pat.hir_id);
4589 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4592 fn overwrite_local_ty_if_err(
4594 local: &'tcx hir::Local<'tcx>,
4598 if ty.references_error() {
4599 // Override the types everywhere with `err()` to avoid knock on errors.
4600 self.write_ty(local.hir_id, ty);
4601 self.write_ty(local.pat.hir_id, ty);
4602 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4603 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4604 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4608 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4609 err.span_suggestion_short(
4610 span.shrink_to_hi(),
4611 "consider using a semicolon here",
4613 Applicability::MachineApplicable,
4617 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4618 // Don't do all the complex logic below for `DeclItem`.
4620 hir::StmtKind::Item(..) => return,
4621 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4624 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4626 // Hide the outer diverging and `has_errors` flags.
4627 let old_diverges = self.diverges.replace(Diverges::Maybe);
4628 let old_has_errors = self.has_errors.replace(false);
4631 hir::StmtKind::Local(ref l) => {
4632 self.check_decl_local(&l);
4635 hir::StmtKind::Item(_) => {}
4636 hir::StmtKind::Expr(ref expr) => {
4637 // Check with expected type of `()`.
4638 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4639 self.suggest_semicolon_at_end(expr.span, err);
4642 hir::StmtKind::Semi(ref expr) => {
4643 self.check_expr(&expr);
4647 // Combine the diverging and `has_error` flags.
4648 self.diverges.set(self.diverges.get() | old_diverges);
4649 self.has_errors.set(self.has_errors.get() | old_has_errors);
4652 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4653 let unit = self.tcx.mk_unit();
4654 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4656 // if the block produces a `!` value, that can always be
4657 // (effectively) coerced to unit.
4659 self.demand_suptype(blk.span, unit, ty);
4663 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4664 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4665 /// when given code like the following:
4667 /// if false { return 0i32; } else { 1u32 }
4668 /// // ^^^^ point at this instead of the whole `if` expression
4670 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4671 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4672 let arm_spans: Vec<Span> = arms
4675 self.in_progress_tables
4676 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4677 .and_then(|arm_ty| {
4678 if arm_ty.is_never() {
4681 Some(match &arm.body.kind {
4682 // Point at the tail expression when possible.
4683 hir::ExprKind::Block(block, _) => {
4684 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4692 if arm_spans.len() == 1 {
4693 return arm_spans[0];
4699 fn check_block_with_expected(
4701 blk: &'tcx hir::Block<'tcx>,
4702 expected: Expectation<'tcx>,
4705 let mut fcx_ps = self.ps.borrow_mut();
4706 let unsafety_state = fcx_ps.recurse(blk);
4707 replace(&mut *fcx_ps, unsafety_state)
4710 // In some cases, blocks have just one exit, but other blocks
4711 // can be targeted by multiple breaks. This can happen both
4712 // with labeled blocks as well as when we desugar
4713 // a `try { ... }` expression.
4717 // 'a: { if true { break 'a Err(()); } Ok(()) }
4719 // Here we would wind up with two coercions, one from
4720 // `Err(())` and the other from the tail expression
4721 // `Ok(())`. If the tail expression is omitted, that's a
4722 // "forced unit" -- unless the block diverges, in which
4723 // case we can ignore the tail expression (e.g., `'a: {
4724 // break 'a 22; }` would not force the type of the block
4726 let tail_expr = blk.expr.as_ref();
4727 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4728 let coerce = if blk.targeted_by_break {
4729 CoerceMany::new(coerce_to_ty)
4731 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4732 Some(e) => slice::from_ref(e),
4735 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4738 let prev_diverges = self.diverges.get();
4739 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4741 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4742 for s in blk.stmts {
4746 // check the tail expression **without** holding the
4747 // `enclosing_breakables` lock below.
4748 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4750 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4751 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4752 let coerce = ctxt.coerce.as_mut().unwrap();
4753 if let Some(tail_expr_ty) = tail_expr_ty {
4754 let tail_expr = tail_expr.unwrap();
4755 let span = self.get_expr_coercion_span(tail_expr);
4756 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4757 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4759 // Subtle: if there is no explicit tail expression,
4760 // that is typically equivalent to a tail expression
4761 // of `()` -- except if the block diverges. In that
4762 // case, there is no value supplied from the tail
4763 // expression (assuming there are no other breaks,
4764 // this implies that the type of the block will be
4767 // #41425 -- label the implicit `()` as being the
4768 // "found type" here, rather than the "expected type".
4769 if !self.diverges.get().is_always() {
4770 // #50009 -- Do not point at the entire fn block span, point at the return type
4771 // span, as it is the cause of the requirement, and
4772 // `consider_hint_about_removing_semicolon` will point at the last expression
4773 // if it were a relevant part of the error. This improves usability in editors
4774 // that highlight errors inline.
4775 let mut sp = blk.span;
4776 let mut fn_span = None;
4777 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4778 let ret_sp = decl.output.span();
4779 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4780 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4781 // output would otherwise be incorrect and even misleading. Make sure
4782 // the span we're aiming at correspond to a `fn` body.
4783 if block_sp == blk.span {
4785 fn_span = Some(ident.span);
4789 coerce.coerce_forced_unit(
4793 if let Some(expected_ty) = expected.only_has_type(self) {
4794 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4796 if let Some(fn_span) = fn_span {
4799 "implicitly returns `()` as its body has no tail or `return` \
4811 // If we can break from the block, then the block's exit is always reachable
4812 // (... as long as the entry is reachable) - regardless of the tail of the block.
4813 self.diverges.set(prev_diverges);
4816 let mut ty = ctxt.coerce.unwrap().complete(self);
4818 if self.has_errors.get() || ty.references_error() {
4819 ty = self.tcx.ty_error()
4822 self.write_ty(blk.hir_id, ty);
4824 *self.ps.borrow_mut() = prev;
4828 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4829 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4831 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4832 | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
4833 let body = self.tcx.hir().body(body_id);
4834 if let ExprKind::Block(block, _) = &body.value.kind {
4835 return Some(block.span);
4843 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4844 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, Ident)> {
4845 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4846 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4849 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4850 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl<'tcx>, Ident, bool)> {
4852 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4853 // This is less than ideal, it will not suggest a return type span on any
4854 // method called `main`, regardless of whether it is actually the entry point,
4855 // but it will still present it as the reason for the expected type.
4856 Some((&sig.decl, ident, ident.name != sym::main))
4858 Node::TraitItem(&hir::TraitItem {
4860 kind: hir::TraitItemKind::Fn(ref sig, ..),
4862 }) => Some((&sig.decl, ident, true)),
4863 Node::ImplItem(&hir::ImplItem {
4865 kind: hir::ImplItemKind::Fn(ref sig, ..),
4867 }) => Some((&sig.decl, ident, false)),
4872 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4873 /// suggestion can be made, `None` otherwise.
4874 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4875 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4876 // `while` before reaching it, as block tail returns are not available in them.
4877 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4878 let parent = self.tcx.hir().get(blk_id);
4879 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4883 /// On implicit return expressions with mismatched types, provides the following suggestions:
4885 /// - Points out the method's return type as the reason for the expected type.
4886 /// - Possible missing semicolon.
4887 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4888 pub fn suggest_mismatched_types_on_tail(
4890 err: &mut DiagnosticBuilder<'_>,
4891 expr: &'tcx hir::Expr<'tcx>,
4897 let expr = expr.peel_drop_temps();
4898 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4899 let mut pointing_at_return_type = false;
4900 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4901 pointing_at_return_type =
4902 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4904 pointing_at_return_type
4907 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4908 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4910 /// fn foo(x: usize) -> usize { x }
4911 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4915 err: &mut DiagnosticBuilder<'_>,
4916 expr: &hir::Expr<'_>,
4920 let hir = self.tcx.hir();
4921 let (def_id, sig) = match found.kind {
4922 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4923 ty::Closure(def_id, substs) => (def_id, substs.as_closure().sig()),
4927 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4928 let sig = self.normalize_associated_types_in(expr.span, &sig);
4929 if self.can_coerce(sig.output(), expected) {
4930 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4931 (String::new(), Applicability::MachineApplicable)
4933 ("...".to_string(), Applicability::HasPlaceholders)
4935 let mut msg = "call this function";
4936 match hir.get_if_local(def_id) {
4938 Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. })
4939 | Node::ImplItem(hir::ImplItem {
4940 kind: hir::ImplItemKind::Fn(_, body_id), ..
4942 | Node::TraitItem(hir::TraitItem {
4943 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Provided(body_id)),
4947 let body = hir.body(*body_id);
4951 .map(|param| match ¶m.pat.kind {
4952 hir::PatKind::Binding(_, _, ident, None)
4953 if ident.name != kw::SelfLower =>
4957 _ => "_".to_string(),
4959 .collect::<Vec<_>>()
4962 Some(Node::Expr(hir::Expr {
4963 kind: ExprKind::Closure(_, _, body_id, _, _),
4964 span: full_closure_span,
4967 if *full_closure_span == expr.span {
4970 msg = "call this closure";
4971 let body = hir.body(*body_id);
4975 .map(|param| match ¶m.pat.kind {
4976 hir::PatKind::Binding(_, _, ident, None)
4977 if ident.name != kw::SelfLower =>
4981 _ => "_".to_string(),
4983 .collect::<Vec<_>>()
4986 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4987 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4988 match def_id.as_local().map(|def_id| hir.def_kind(def_id)) {
4989 Some(DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4990 msg = "instantiate this tuple variant";
4992 Some(DefKind::Ctor(CtorOf::Struct, _)) => {
4993 msg = "instantiate this tuple struct";
4998 Some(Node::ForeignItem(hir::ForeignItem {
4999 kind: hir::ForeignItemKind::Fn(_, idents, _),
5005 if ident.name != kw::SelfLower {
5011 .collect::<Vec<_>>()
5014 Some(Node::TraitItem(hir::TraitItem {
5015 kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Required(idents)),
5021 if ident.name != kw::SelfLower {
5027 .collect::<Vec<_>>()
5032 err.span_suggestion_verbose(
5033 expr.span.shrink_to_hi(),
5034 &format!("use parentheses to {}", msg),
5035 format!("({})", sugg_call),
5043 pub fn suggest_deref_ref_or_into(
5045 err: &mut DiagnosticBuilder<'_>,
5046 expr: &hir::Expr<'_>,
5049 expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
5051 if let Some((sp, msg, suggestion, applicability)) = self.check_ref(expr, found, expected) {
5052 err.span_suggestion(sp, msg, suggestion, applicability);
5053 } else if let (ty::FnDef(def_id, ..), true) =
5054 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
5056 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
5057 let sp = self.sess().source_map().guess_head_span(sp);
5058 err.span_label(sp, &format!("{} defined here", found));
5060 } else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
5061 let is_struct_pat_shorthand_field =
5062 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
5063 let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
5064 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
5065 let mut suggestions = iter::repeat(&expr_text)
5066 .zip(methods.iter())
5067 .filter_map(|(receiver, method)| {
5068 let method_call = format!(".{}()", method.ident);
5069 if receiver.ends_with(&method_call) {
5070 None // do not suggest code that is already there (#53348)
5072 let method_call_list = [".to_vec()", ".to_string()"];
5073 let sugg = if receiver.ends_with(".clone()")
5074 && method_call_list.contains(&method_call.as_str())
5076 let max_len = receiver.rfind('.').unwrap();
5077 format!("{}{}", &receiver[..max_len], method_call)
5079 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
5080 format!("({}){}", receiver, method_call)
5082 format!("{}{}", receiver, method_call)
5085 Some(if is_struct_pat_shorthand_field {
5086 format!("{}: {}", receiver, sugg)
5093 if suggestions.peek().is_some() {
5094 err.span_suggestions(
5096 "try using a conversion method",
5098 Applicability::MaybeIncorrect,
5105 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
5106 /// in the heap by calling `Box::new()`.
5107 fn suggest_boxing_when_appropriate(
5109 err: &mut DiagnosticBuilder<'_>,
5110 expr: &hir::Expr<'_>,
5114 if self.tcx.hir().is_inside_const_context(expr.hir_id) {
5115 // Do not suggest `Box::new` in const context.
5118 if !expected.is_box() || found.is_box() {
5121 let boxed_found = self.tcx.mk_box(found);
5122 if let (true, Ok(snippet)) = (
5123 self.can_coerce(boxed_found, expected),
5124 self.sess().source_map().span_to_snippet(expr.span),
5126 err.span_suggestion(
5128 "store this in the heap by calling `Box::new`",
5129 format!("Box::new({})", snippet),
5130 Applicability::MachineApplicable,
5133 "for more on the distinction between the stack and the heap, read \
5134 https://doc.rust-lang.org/book/ch15-01-box.html, \
5135 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
5136 https://doc.rust-lang.org/std/boxed/index.html",
5141 /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
5142 fn suggest_calling_boxed_future_when_appropriate(
5144 err: &mut DiagnosticBuilder<'_>,
5145 expr: &hir::Expr<'_>,
5151 if self.tcx.hir().is_inside_const_context(expr.hir_id) {
5152 // Do not suggest `Box::new` in const context.
5155 let pin_did = self.tcx.lang_items().pin_type();
5156 match expected.kind {
5157 ty::Adt(def, _) if Some(def.did) != pin_did => return false,
5158 // This guards the `unwrap` and `mk_box` below.
5159 _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
5162 let boxed_found = self.tcx.mk_box(found);
5163 let new_found = self.tcx.mk_lang_item(boxed_found, PinTypeLangItem).unwrap();
5164 if let (true, Ok(snippet)) = (
5165 self.can_coerce(new_found, expected),
5166 self.sess().source_map().span_to_snippet(expr.span),
5169 ty::Adt(def, _) if def.is_box() => {
5170 err.help("use `Box::pin`");
5173 err.span_suggestion(
5175 "you need to pin and box this expression",
5176 format!("Box::pin({})", snippet),
5177 Applicability::MachineApplicable,
5187 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
5191 /// bar_that_returns_u32()
5195 /// This routine checks if the return expression in a block would make sense on its own as a
5196 /// statement and the return type has been left as default or has been specified as `()`. If so,
5197 /// it suggests adding a semicolon.
5198 fn suggest_missing_semicolon(
5200 err: &mut DiagnosticBuilder<'_>,
5201 expression: &'tcx hir::Expr<'tcx>,
5205 if expected.is_unit() {
5206 // `BlockTailExpression` only relevant if the tail expr would be
5207 // useful on its own.
5208 match expression.kind {
5210 | ExprKind::MethodCall(..)
5211 | ExprKind::Loop(..)
5212 | ExprKind::Match(..)
5213 | ExprKind::Block(..) => {
5214 err.span_suggestion(
5215 cause_span.shrink_to_hi(),
5216 "try adding a semicolon",
5218 Applicability::MachineApplicable,
5226 /// A possible error is to forget to add a return type that is needed:
5230 /// bar_that_returns_u32()
5234 /// This routine checks if the return type is left as default, the method is not part of an
5235 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5237 fn suggest_missing_return_type(
5239 err: &mut DiagnosticBuilder<'_>,
5240 fn_decl: &hir::FnDecl<'_>,
5245 // Only suggest changing the return type for methods that
5246 // haven't set a return type at all (and aren't `fn main()` or an impl).
5247 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5248 (&hir::FnRetTy::DefaultReturn(span), true, true, true) => {
5249 err.span_suggestion(
5251 "try adding a return type",
5252 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5253 Applicability::MachineApplicable,
5257 (&hir::FnRetTy::DefaultReturn(span), false, true, true) => {
5258 err.span_label(span, "possibly return type missing here?");
5261 (&hir::FnRetTy::DefaultReturn(span), _, false, true) => {
5262 // `fn main()` must return `()`, do not suggest changing return type
5263 err.span_label(span, "expected `()` because of default return type");
5266 // expectation was caused by something else, not the default return
5267 (&hir::FnRetTy::DefaultReturn(_), _, _, false) => false,
5268 (&hir::FnRetTy::Return(ref ty), _, _, _) => {
5269 // Only point to return type if the expected type is the return type, as if they
5270 // are not, the expectation must have been caused by something else.
5271 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5273 let ty = AstConv::ast_ty_to_ty(self, ty);
5274 debug!("suggest_missing_return_type: return type {:?}", ty);
5275 debug!("suggest_missing_return_type: expected type {:?}", ty);
5276 if ty.kind == expected.kind {
5277 err.span_label(sp, format!("expected `{}` because of return type", expected));
5285 /// A possible error is to forget to add `.await` when using futures:
5288 /// async fn make_u32() -> u32 {
5292 /// fn take_u32(x: u32) {}
5294 /// async fn foo() {
5295 /// let x = make_u32();
5300 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5301 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5302 /// `.await` to the tail of the expression.
5303 fn suggest_missing_await(
5305 err: &mut DiagnosticBuilder<'_>,
5306 expr: &hir::Expr<'_>,
5310 debug!("suggest_missing_await: expr={:?} expected={:?}, found={:?}", expr, expected, found);
5311 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5312 // body isn't `async`.
5313 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5314 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5315 let body = self.tcx().hir().body(body_id);
5316 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5318 // Check for `Future` implementations by constructing a predicate to
5319 // prove: `<T as Future>::Output == U`
5320 let future_trait = self.tcx.require_lang_item(FutureTraitLangItem, Some(sp));
5321 let item_def_id = self
5323 .associated_items(future_trait)
5324 .in_definition_order()
5328 // `<T as Future>::Output`
5329 let projection_ty = ty::ProjectionTy {
5333 .mk_substs_trait(found, self.fresh_substs_for_item(sp, item_def_id)),
5339 ty::PredicateKind::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5343 .to_predicate(self.tcx);
5344 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5346 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5348 if self.infcx.predicate_may_hold(&obligation) {
5349 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5350 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5351 err.span_suggestion(
5353 "consider using `.await` here",
5354 format!("{}.await", code),
5355 Applicability::MaybeIncorrect,
5358 debug!("suggest_missing_await: no snippet for {:?}", sp);
5361 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5367 fn note_need_for_fn_pointer(
5369 err: &mut DiagnosticBuilder<'_>,
5373 let (sig, did, substs) = match (&expected.kind, &found.kind) {
5374 (ty::FnDef(did1, substs1), ty::FnDef(did2, substs2)) => {
5375 let sig1 = self.tcx.fn_sig(*did1).subst(self.tcx, substs1);
5376 let sig2 = self.tcx.fn_sig(*did2).subst(self.tcx, substs2);
5381 "different `fn` items always have unique types, even if their signatures are \
5384 (sig1, *did1, substs1)
5386 (ty::FnDef(did, substs), ty::FnPtr(sig2)) => {
5387 let sig1 = self.tcx.fn_sig(*did).subst(self.tcx, substs);
5391 (sig1, *did, substs)
5395 err.help(&format!("change the expected type to be function pointer `{}`", sig));
5397 "if the expected type is due to type inference, cast the expected `fn` to a function \
5398 pointer: `{} as {}`",
5399 self.tcx.def_path_str_with_substs(did, substs),
5404 /// A common error is to add an extra semicolon:
5407 /// fn foo() -> usize {
5412 /// This routine checks if the final statement in a block is an
5413 /// expression with an explicit semicolon whose type is compatible
5414 /// with `expected_ty`. If so, it suggests removing the semicolon.
5415 fn consider_hint_about_removing_semicolon(
5417 blk: &'tcx hir::Block<'tcx>,
5418 expected_ty: Ty<'tcx>,
5419 err: &mut DiagnosticBuilder<'_>,
5421 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5422 err.span_suggestion(
5424 "consider removing this semicolon",
5426 Applicability::MachineApplicable,
5431 fn could_remove_semicolon(
5433 blk: &'tcx hir::Block<'tcx>,
5434 expected_ty: Ty<'tcx>,
5436 // Be helpful when the user wrote `{... expr;}` and
5437 // taking the `;` off is enough to fix the error.
5438 let last_stmt = blk.stmts.last()?;
5439 let last_expr = match last_stmt.kind {
5440 hir::StmtKind::Semi(ref e) => e,
5443 let last_expr_ty = self.node_ty(last_expr.hir_id);
5444 if matches!(last_expr_ty.kind, ty::Error(_))
5445 || self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err()
5449 let original_span = original_sp(last_stmt.span, blk.span);
5450 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5453 // Instantiates the given path, which must refer to an item with the given
5454 // number of type parameters and type.
5455 pub fn instantiate_value_path(
5457 segments: &[hir::PathSegment<'_>],
5458 self_ty: Option<Ty<'tcx>>,
5462 ) -> (Ty<'tcx>, Res) {
5464 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5465 segments, self_ty, res, hir_id,
5470 let path_segs = match res {
5471 Res::Local(_) | Res::SelfCtor(_) => vec![],
5472 Res::Def(kind, def_id) => {
5473 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5475 _ => bug!("instantiate_value_path on {:?}", res),
5478 let mut user_self_ty = None;
5479 let mut is_alias_variant_ctor = false;
5481 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5482 if let Some(self_ty) = self_ty {
5483 let adt_def = self_ty.ty_adt_def().unwrap();
5484 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5485 is_alias_variant_ctor = true;
5488 Res::Def(DefKind::AssocFn | DefKind::AssocConst, def_id) => {
5489 let container = tcx.associated_item(def_id).container;
5490 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5492 ty::TraitContainer(trait_did) => {
5493 callee::check_legal_trait_for_method_call(tcx, span, None, trait_did)
5495 ty::ImplContainer(impl_def_id) => {
5496 if segments.len() == 1 {
5497 // `<T>::assoc` will end up here, and so
5498 // can `T::assoc`. It this came from an
5499 // inherent impl, we need to record the
5500 // `T` for posterity (see `UserSelfTy` for
5502 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5503 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5511 // Now that we have categorized what space the parameters for each
5512 // segment belong to, let's sort out the parameters that the user
5513 // provided (if any) into their appropriate spaces. We'll also report
5514 // errors if type parameters are provided in an inappropriate place.
5516 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5517 let generics_has_err = AstConv::prohibit_generics(
5519 segments.iter().enumerate().filter_map(|(index, seg)| {
5520 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5528 if let Res::Local(hid) = res {
5529 let ty = self.local_ty(span, hid).decl_ty;
5530 let ty = self.normalize_associated_types_in(span, &ty);
5531 self.write_ty(hir_id, ty);
5535 if generics_has_err {
5536 // Don't try to infer type parameters when prohibited generic arguments were given.
5537 user_self_ty = None;
5540 // Now we have to compare the types that the user *actually*
5541 // provided against the types that were *expected*. If the user
5542 // did not provide any types, then we want to substitute inference
5543 // variables. If the user provided some types, we may still need
5544 // to add defaults. If the user provided *too many* types, that's
5547 let mut infer_args_for_err = FxHashSet::default();
5548 for &PathSeg(def_id, index) in &path_segs {
5549 let seg = &segments[index];
5550 let generics = tcx.generics_of(def_id);
5551 // Argument-position `impl Trait` is treated as a normal generic
5552 // parameter internally, but we don't allow users to specify the
5553 // parameter's value explicitly, so we have to do some error-
5555 if let GenericArgCountResult {
5556 correct: Err(GenericArgCountMismatch { reported: Some(ErrorReported), .. }),
5558 } = AstConv::check_generic_arg_count_for_call(
5559 tcx, span, &generics, &seg, false, // `is_method_call`
5561 infer_args_for_err.insert(index);
5562 self.set_tainted_by_errors(); // See issue #53251.
5566 let has_self = path_segs
5568 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5571 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5572 let ty = self.normalize_ty(span, tcx.at(span).type_of(impl_def_id));
5574 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5575 let variant = adt_def.non_enum_variant();
5576 let ctor_def_id = variant.ctor_def_id.unwrap();
5578 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5583 let mut err = tcx.sess.struct_span_err(
5585 "the `Self` constructor can only be used with tuple or unit structs",
5587 if let Some(adt_def) = ty.ty_adt_def() {
5588 match adt_def.adt_kind() {
5590 err.help("did you mean to use one of the enum's variants?");
5592 AdtKind::Struct | AdtKind::Union => {
5593 err.span_suggestion(
5595 "use curly brackets",
5596 String::from("Self { /* fields */ }"),
5597 Applicability::HasPlaceholders,
5604 return (tcx.ty_error(), res);
5610 let def_id = res.def_id();
5612 // The things we are substituting into the type should not contain
5613 // escaping late-bound regions, and nor should the base type scheme.
5614 let ty = tcx.type_of(def_id);
5616 let arg_count = GenericArgCountResult {
5617 explicit_late_bound: ExplicitLateBound::No,
5618 correct: if infer_args_for_err.is_empty() {
5621 Err(GenericArgCountMismatch::default())
5625 let substs = self_ctor_substs.unwrap_or_else(|| {
5626 AstConv::create_substs_for_generic_args(
5633 // Provide the generic args, and whether types should be inferred.
5635 if let Some(&PathSeg(_, index)) =
5636 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5638 // If we've encountered an `impl Trait`-related error, we're just
5639 // going to infer the arguments for better error messages.
5640 if !infer_args_for_err.contains(&index) {
5641 // Check whether the user has provided generic arguments.
5642 if let Some(ref data) = segments[index].args {
5643 return (Some(data), segments[index].infer_args);
5646 return (None, segments[index].infer_args);
5651 // Provide substitutions for parameters for which (valid) arguments have been provided.
5652 |param, arg| match (¶m.kind, arg) {
5653 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5654 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5656 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5657 self.to_ty(ty).into()
5659 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5660 self.to_const(&ct.value).into()
5662 _ => unreachable!(),
5664 // Provide substitutions for parameters for which arguments are inferred.
5665 |substs, param, infer_args| {
5667 GenericParamDefKind::Lifetime => {
5668 self.re_infer(Some(param), span).unwrap().into()
5670 GenericParamDefKind::Type { has_default, .. } => {
5671 if !infer_args && has_default {
5672 // If we have a default, then we it doesn't matter that we're not
5673 // inferring the type arguments: we provide the default where any
5675 let default = tcx.type_of(param.def_id);
5678 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5682 // If no type arguments were provided, we have to infer them.
5683 // This case also occurs as a result of some malformed input, e.g.
5684 // a lifetime argument being given instead of a type parameter.
5685 // Using inference instead of `Error` gives better error messages.
5686 self.var_for_def(span, param)
5689 GenericParamDefKind::Const => {
5690 // FIXME(const_generics:defaults)
5691 // No const parameters were provided, we have to infer them.
5692 self.var_for_def(span, param)
5698 assert!(!substs.has_escaping_bound_vars());
5699 assert!(!ty.has_escaping_bound_vars());
5701 // First, store the "user substs" for later.
5702 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5704 self.add_required_obligations(span, def_id, &substs);
5706 // Substitute the values for the type parameters into the type of
5707 // the referenced item.
5708 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5710 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5711 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5712 // is inherent, there is no `Self` parameter; instead, the impl needs
5713 // type parameters, which we can infer by unifying the provided `Self`
5714 // with the substituted impl type.
5715 // This also occurs for an enum variant on a type alias.
5716 let ty = tcx.type_of(impl_def_id);
5718 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5719 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5720 Ok(ok) => self.register_infer_ok_obligations(ok),
5722 self.tcx.sess.delay_span_bug(
5725 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5734 self.check_rustc_args_require_const(def_id, hir_id, span);
5736 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5737 self.write_substs(hir_id, substs);
5739 (ty_substituted, res)
5742 /// Add all the obligations that are required, substituting and normalized appropriately.
5743 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5744 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5746 for (i, mut obligation) in traits::predicates_for_generics(
5747 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5753 // This makes the error point at the bound, but we want to point at the argument
5754 if let Some(span) = spans.get(i) {
5755 obligation.cause.make_mut().code = traits::BindingObligation(def_id, *span);
5757 self.register_predicate(obligation);
5761 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5762 // We're only interested in functions tagged with
5763 // #[rustc_args_required_const], so ignore anything that's not.
5764 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5768 // If our calling expression is indeed the function itself, we're good!
5769 // If not, generate an error that this can only be called directly.
5770 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5771 if let ExprKind::Call(ref callee, ..) = expr.kind {
5772 if callee.hir_id == hir_id {
5778 self.tcx.sess.span_err(
5780 "this function can only be invoked directly, not through a function pointer",
5784 /// Resolves `typ` by a single level if `typ` is a type variable.
5785 /// If no resolution is possible, then an error is reported.
5786 /// Numeric inference variables may be left unresolved.
5787 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5788 let ty = self.resolve_vars_with_obligations(ty);
5789 if !ty.is_ty_var() {
5792 if !self.is_tainted_by_errors() {
5793 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5794 .note("type must be known at this point")
5797 let err = self.tcx.ty_error();
5798 self.demand_suptype(sp, err, ty);
5803 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5806 ctxt: BreakableCtxt<'tcx>,
5808 ) -> (BreakableCtxt<'tcx>, R) {
5811 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5812 index = enclosing_breakables.stack.len();
5813 enclosing_breakables.by_id.insert(id, index);
5814 enclosing_breakables.stack.push(ctxt);
5818 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5819 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5820 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5821 enclosing_breakables.stack.pop().expect("missing breakable context")
5826 /// Instantiate a QueryResponse in a probe context, without a
5827 /// good ObligationCause.
5828 fn probe_instantiate_query_response(
5831 original_values: &OriginalQueryValues<'tcx>,
5832 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5833 ) -> InferResult<'tcx, Ty<'tcx>> {
5834 self.instantiate_query_response_and_region_obligations(
5835 &traits::ObligationCause::misc(span, self.body_id),
5842 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5843 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5844 let mut contained_in_place = false;
5846 while let hir::Node::Expr(parent_expr) =
5847 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5849 match &parent_expr.kind {
5850 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5851 if lhs.hir_id == expr_id {
5852 contained_in_place = true;
5858 expr_id = parent_expr.hir_id;
5865 fn check_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5866 debug!("check_type_params_are_used(generics={:?}, ty={:?})", generics, ty);
5868 assert_eq!(generics.parent, None);
5870 if generics.own_counts().types == 0 {
5874 let mut params_used = BitSet::new_empty(generics.params.len());
5876 if ty.references_error() {
5877 // If there is already another error, do not emit
5878 // an error for not using a type parameter.
5879 assert!(tcx.sess.has_errors());
5883 for leaf in ty.walk() {
5884 if let GenericArgKind::Type(leaf_ty) = leaf.unpack() {
5885 if let ty::Param(param) = leaf_ty.kind {
5886 debug!("found use of ty param {:?}", param);
5887 params_used.insert(param.index);
5892 for param in &generics.params {
5893 if !params_used.contains(param.index) {
5894 if let ty::GenericParamDefKind::Type { .. } = param.kind {
5895 let span = tcx.def_span(param.def_id);
5900 "type parameter `{}` is unused",
5903 .span_label(span, "unused type parameter")
5910 fn fatally_break_rust(sess: &Session) {
5911 let handler = sess.diagnostic();
5912 handler.span_bug_no_panic(
5914 "It looks like you're trying to break rust; would you like some ICE?",
5916 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5917 handler.note_without_error(
5918 "we would appreciate a joke overview: \
5919 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5921 handler.note_without_error(&format!(
5922 "rustc {} running on {}",
5923 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5924 config::host_triple(),
5928 fn potentially_plural_count(count: usize, word: &str) -> String {
5929 format!("{} {}{}", count, word, pluralize!(count))