1 // ignore-tidy-filelength
7 Within the check phase of type check, we check each item one at a time
8 (bodies of function expressions are checked as part of the containing
9 function). Inference is used to supply types wherever they are unknown.
11 By far the most complex case is checking the body of a function. This
12 can be broken down into several distinct phases:
14 - gather: creates type variables to represent the type of each local
15 variable and pattern binding.
17 - main: the main pass does the lion's share of the work: it
18 determines the types of all expressions, resolves
19 methods, checks for most invalid conditions, and so forth. In
20 some cases, where a type is unknown, it may create a type or region
21 variable and use that as the type of an expression.
23 In the process of checking, various constraints will be placed on
24 these type variables through the subtyping relationships requested
25 through the `demand` module. The `infer` module is in charge
26 of resolving those constraints.
28 - regionck: after main is complete, the regionck pass goes over all
29 types looking for regions and making sure that they did not escape
30 into places they are not in scope. This may also influence the
31 final assignments of the various region variables if there is some
34 - vtable: find and records the impls to use for each trait bound that
35 appears on a type parameter.
37 - writeback: writes the final types within a function body, replacing
38 type variables with their final inferred types. These final types
39 are written into the `tcx.node_types` table, which should *never* contain
40 any reference to a type variable.
44 While type checking a function, the intermediate types for the
45 expressions, blocks, and so forth contained within the function are
46 stored in `fcx.node_types` and `fcx.node_substs`. These types
47 may contain unresolved type variables. After type checking is
48 complete, the functions in the writeback module are used to take the
49 types from this table, resolve them, and then write them into their
50 permanent home in the type context `tcx`.
52 This means that during inferencing you should use `fcx.write_ty()`
53 and `fcx.expr_ty()` / `fcx.node_ty()` to write/obtain the types of
54 nodes within the function.
56 The types of top-level items, which never contain unbound type
57 variables, are stored directly into the `tcx` tables.
59 N.B., a type variable is not the same thing as a type parameter. A
60 type variable is rather an "instance" of a type parameter: that is,
61 given a generic function `fn foo<T>(t: T)`: while checking the
62 function `foo`, the type `ty_param(0)` refers to the type `T`, which
63 is treated in abstract. When `foo()` is called, however, `T` will be
64 substituted for a fresh type variable `N`. This variable will
65 eventually be resolved to some concrete type (which might itself be
80 mod generator_interior;
90 use crate::astconv::{AstConv, PathSeg};
91 use crate::middle::lang_items;
92 use crate::namespace::Namespace;
93 use rustc::hir::map::Map;
94 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
95 use rustc::infer::error_reporting::TypeAnnotationNeeded::E0282;
96 use rustc::infer::opaque_types::OpaqueTypeDecl;
97 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
98 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
99 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
100 use rustc::middle::region;
101 use rustc::mir::interpret::ConstValue;
102 use rustc::session::parse::feature_err;
103 use rustc::traits::error_reporting::recursive_type_with_infinite_size_error;
104 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
105 use rustc::ty::adjustment::{
106 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast,
108 use rustc::ty::fold::{TypeFoldable, TypeFolder};
109 use rustc::ty::layout::VariantIdx;
110 use rustc::ty::query::Providers;
111 use rustc::ty::subst::{GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSelfTy, UserSubsts};
112 use rustc::ty::util::{Discr, IntTypeExt, Representability};
114 self, AdtKind, CanonicalUserType, Const, GenericParamDefKind, RegionKind, ToPolyTraitRef,
115 ToPredicate, Ty, TyCtxt, UserType,
117 use rustc_data_structures::captures::Captures;
118 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
119 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
120 use rustc_hir as hir;
121 use rustc_hir::def::{CtorOf, DefKind, Res};
122 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LOCAL_CRATE};
123 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
124 use rustc_hir::itemlikevisit::ItemLikeVisitor;
125 use rustc_hir::{ExprKind, GenericArg, HirIdMap, ItemKind, Node, PatKind, QPath};
126 use rustc_index::vec::Idx;
127 use rustc_span::hygiene::DesugaringKind;
128 use rustc_span::source_map::{original_sp, DUMMY_SP};
129 use rustc_span::symbol::{kw, sym, Ident};
130 use rustc_span::{self, BytePos, MultiSpan, Span};
131 use rustc_target::spec::abi::Abi;
134 use syntax::util::parser::ExprPrecedence;
136 use rustc_error_codes::*;
138 use std::cell::{Cell, Ref, RefCell, RefMut};
140 use std::collections::hash_map::Entry;
142 use std::mem::replace;
143 use std::ops::{self, Deref};
147 use crate::require_c_abi_if_c_variadic;
148 use crate::session::config::EntryFnType;
149 use crate::session::Session;
150 use crate::util::common::{indenter, ErrorReported};
151 use crate::TypeAndSubsts;
153 use self::autoderef::Autoderef;
154 use self::callee::DeferredCallResolution;
155 use self::coercion::{CoerceMany, DynamicCoerceMany};
156 use self::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
157 use self::method::{MethodCallee, SelfSource};
158 pub use self::Expectation::*;
159 use self::TupleArgumentsFlag::*;
162 macro_rules! type_error_struct {
163 ($session:expr, $span:expr, $typ:expr, $code:ident, $($message:tt)*) => ({
164 if $typ.references_error() {
165 $session.diagnostic().struct_dummy()
167 rustc_errors::struct_span_err!($session, $span, $code, $($message)*)
172 /// The type of a local binding, including the revealed type for anon types.
173 #[derive(Copy, Clone, Debug)]
174 pub struct LocalTy<'tcx> {
176 revealed_ty: Ty<'tcx>,
179 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
180 #[derive(Copy, Clone)]
181 struct MaybeInProgressTables<'a, 'tcx> {
182 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
185 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
186 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
187 match self.maybe_tables {
188 Some(tables) => tables.borrow(),
189 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables"),
193 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
194 match self.maybe_tables {
195 Some(tables) => tables.borrow_mut(),
196 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables"),
201 /// Closures defined within the function. For example:
204 /// bar(move|| { ... })
207 /// Here, the function `foo()` and the closure passed to
208 /// `bar()` will each have their own `FnCtxt`, but they will
209 /// share the inherited fields.
210 pub struct Inherited<'a, 'tcx> {
211 infcx: InferCtxt<'a, 'tcx>,
213 tables: MaybeInProgressTables<'a, 'tcx>,
215 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
217 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
219 // Some additional `Sized` obligations badly affect type inference.
220 // These obligations are added in a later stage of typeck.
221 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
223 // When we process a call like `c()` where `c` is a closure type,
224 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
225 // `FnOnce` closure. In that case, we defer full resolution of the
226 // call until upvar inference can kick in and make the
227 // decision. We keep these deferred resolutions grouped by the
228 // def-id of the closure, so that once we decide, we can easily go
229 // back and process them.
230 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
232 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
234 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
236 // Opaque types found in explicit return types and their
237 // associated fresh inference variable. Writeback resolves these
238 // variables to get the concrete type, which can be used to
239 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
240 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
242 /// A map from inference variables created from opaque
243 /// type instantiations (`ty::Infer`) to the actual opaque
244 /// type (`ty::Opaque`). Used during fallback to map unconstrained
245 /// opaque type inference variables to their corresponding
247 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
249 /// Each type parameter has an implicit region bound that
250 /// indicates it must outlive at least the function body (the user
251 /// may specify stronger requirements). This field indicates the
252 /// region of the callee. If it is `None`, then the parameter
253 /// environment is for an item or something where the "callee" is
255 implicit_region_bound: Option<ty::Region<'tcx>>,
257 body_id: Option<hir::BodyId>,
260 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
261 type Target = InferCtxt<'a, 'tcx>;
262 fn deref(&self) -> &Self::Target {
267 /// When type-checking an expression, we propagate downward
268 /// whatever type hint we are able in the form of an `Expectation`.
269 #[derive(Copy, Clone, Debug)]
270 pub enum Expectation<'tcx> {
271 /// We know nothing about what type this expression should have.
274 /// This expression should have the type given (or some subtype).
275 ExpectHasType(Ty<'tcx>),
277 /// This expression will be cast to the `Ty`.
278 ExpectCastableToType(Ty<'tcx>),
280 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
281 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
282 ExpectRvalueLikeUnsized(Ty<'tcx>),
285 impl<'a, 'tcx> Expectation<'tcx> {
286 // Disregard "castable to" expectations because they
287 // can lead us astray. Consider for example `if cond
288 // {22} else {c} as u8` -- if we propagate the
289 // "castable to u8" constraint to 22, it will pick the
290 // type 22u8, which is overly constrained (c might not
291 // be a u8). In effect, the problem is that the
292 // "castable to" expectation is not the tightest thing
293 // we can say, so we want to drop it in this case.
294 // The tightest thing we can say is "must unify with
295 // else branch". Note that in the case of a "has type"
296 // constraint, this limitation does not hold.
298 // If the expected type is just a type variable, then don't use
299 // an expected type. Otherwise, we might write parts of the type
300 // when checking the 'then' block which are incompatible with the
302 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
304 ExpectHasType(ety) => {
305 let ety = fcx.shallow_resolve(ety);
306 if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
308 ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
313 /// Provides an expectation for an rvalue expression given an *optional*
314 /// hint, which is not required for type safety (the resulting type might
315 /// be checked higher up, as is the case with `&expr` and `box expr`), but
316 /// is useful in determining the concrete type.
318 /// The primary use case is where the expected type is a fat pointer,
319 /// like `&[isize]`. For example, consider the following statement:
321 /// let x: &[isize] = &[1, 2, 3];
323 /// In this case, the expected type for the `&[1, 2, 3]` expression is
324 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
325 /// expectation `ExpectHasType([isize])`, that would be too strong --
326 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
327 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
328 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
329 /// which still is useful, because it informs integer literals and the like.
330 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
331 /// for examples of where this comes up,.
332 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
333 match fcx.tcx.struct_tail_without_normalization(ty).kind {
334 ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
335 _ => ExpectHasType(ty),
339 // Resolves `expected` by a single level if it is a variable. If
340 // there is no expected type or resolution is not possible (e.g.,
341 // no constraints yet present), just returns `None`.
342 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
344 NoExpectation => NoExpectation,
345 ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
346 ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
347 ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
351 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
352 match self.resolve(fcx) {
353 NoExpectation => None,
354 ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
358 /// It sometimes happens that we want to turn an expectation into
359 /// a **hard constraint** (i.e., something that must be satisfied
360 /// for the program to type-check). `only_has_type` will return
361 /// such a constraint, if it exists.
362 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
363 match self.resolve(fcx) {
364 ExpectHasType(ty) => Some(ty),
365 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
369 /// Like `only_has_type`, but instead of returning `None` if no
370 /// hard constraint exists, creates a fresh type variable.
371 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
372 self.only_has_type(fcx).unwrap_or_else(|| {
373 fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
378 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
385 fn maybe_mut_place(m: hir::Mutability) -> Self {
387 hir::Mutability::Mut => Needs::MutPlace,
388 hir::Mutability::Not => Needs::None,
393 #[derive(Copy, Clone)]
394 pub struct UnsafetyState {
396 pub unsafety: hir::Unsafety,
397 pub unsafe_push_count: u32,
402 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
403 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
406 pub fn recurse(&mut self, blk: &hir::Block<'_>) -> UnsafetyState {
407 use hir::BlockCheckMode;
408 match self.unsafety {
409 // If this unsafe, then if the outer function was already marked as
410 // unsafe we shouldn't attribute the unsafe'ness to the block. This
411 // way the block can be warned about instead of ignoring this
412 // extraneous block (functions are never warned about).
413 hir::Unsafety::Unsafe if self.from_fn => *self,
416 let (unsafety, def, count) = match blk.rules {
417 BlockCheckMode::PushUnsafeBlock(..) => {
418 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
420 BlockCheckMode::PopUnsafeBlock(..) => {
421 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
423 BlockCheckMode::UnsafeBlock(..) => {
424 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
426 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
428 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
434 #[derive(Debug, Copy, Clone)]
440 /// Tracks whether executing a node may exit normally (versus
441 /// return/break/panic, which "diverge", leaving dead code in their
442 /// wake). Tracked semi-automatically (through type variables marked
443 /// as diverging), with some manual adjustments for control-flow
444 /// primitives (approximating a CFG).
445 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
447 /// Potentially unknown, some cases converge,
448 /// others require a CFG to determine them.
451 /// Definitely known to diverge and therefore
452 /// not reach the next sibling or its parent.
454 /// The `Span` points to the expression
455 /// that caused us to diverge
456 /// (e.g. `return`, `break`, etc).
458 /// In some cases (e.g. a `match` expression
459 /// where all arms diverge), we may be
460 /// able to provide a more informative
461 /// message to the user.
462 /// If this is `None`, a default messsage
463 /// will be generated, which is suitable
465 custom_note: Option<&'static str>,
468 /// Same as `Always` but with a reachability
469 /// warning already emitted.
473 // Convenience impls for combining `Diverges`.
475 impl ops::BitAnd for Diverges {
477 fn bitand(self, other: Self) -> Self {
478 cmp::min(self, other)
482 impl ops::BitOr for Diverges {
484 fn bitor(self, other: Self) -> Self {
485 cmp::max(self, other)
489 impl ops::BitAndAssign for Diverges {
490 fn bitand_assign(&mut self, other: Self) {
491 *self = *self & other;
495 impl ops::BitOrAssign for Diverges {
496 fn bitor_assign(&mut self, other: Self) {
497 *self = *self | other;
502 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
503 fn always(span: Span) -> Diverges {
504 Diverges::Always { span, custom_note: None }
507 fn is_always(self) -> bool {
508 // Enum comparison ignores the
509 // contents of fields, so we just
510 // fill them in with garbage here.
511 self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
515 pub struct BreakableCtxt<'tcx> {
518 // this is `null` for loops where break with a value is illegal,
519 // such as `while`, `for`, and `while let`
520 coerce: Option<DynamicCoerceMany<'tcx>>,
523 pub struct EnclosingBreakables<'tcx> {
524 stack: Vec<BreakableCtxt<'tcx>>,
525 by_id: HirIdMap<usize>,
528 impl<'tcx> EnclosingBreakables<'tcx> {
529 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
530 self.opt_find_breakable(target_id).unwrap_or_else(|| {
531 bug!("could not find enclosing breakable with id {}", target_id);
535 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
536 match self.by_id.get(&target_id) {
537 Some(ix) => Some(&mut self.stack[*ix]),
543 pub struct FnCtxt<'a, 'tcx> {
546 /// The parameter environment used for proving trait obligations
547 /// in this function. This can change when we descend into
548 /// closures (as they bring new things into scope), hence it is
549 /// not part of `Inherited` (as of the time of this writing,
550 /// closures do not yet change the environment, but they will
552 param_env: ty::ParamEnv<'tcx>,
554 /// Number of errors that had been reported when we started
555 /// checking this function. On exit, if we find that *more* errors
556 /// have been reported, we will skip regionck and other work that
557 /// expects the types within the function to be consistent.
558 // FIXME(matthewjasper) This should not exist, and it's not correct
559 // if type checking is run in parallel.
560 err_count_on_creation: usize,
562 /// If `Some`, this stores coercion information for returned
563 /// expressions. If `None`, this is in a context where return is
564 /// inappropriate, such as a const expression.
566 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
567 /// can track all the return expressions and then use them to
568 /// compute a useful coercion from the set, similar to a match
569 /// expression or other branching context. You can use methods
570 /// like `expected_ty` to access the declared return type (if
572 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
574 /// First span of a return site that we find. Used in error messages.
575 ret_coercion_span: RefCell<Option<Span>>,
577 yield_ty: Option<Ty<'tcx>>,
579 ps: RefCell<UnsafetyState>,
581 /// Whether the last checked node generates a divergence (e.g.,
582 /// `return` will set this to `Always`). In general, when entering
583 /// an expression or other node in the tree, the initial value
584 /// indicates whether prior parts of the containing expression may
585 /// have diverged. It is then typically set to `Maybe` (and the
586 /// old value remembered) for processing the subparts of the
587 /// current expression. As each subpart is processed, they may set
588 /// the flag to `Always`, etc. Finally, at the end, we take the
589 /// result and "union" it with the original value, so that when we
590 /// return the flag indicates if any subpart of the parent
591 /// expression (up to and including this part) has diverged. So,
592 /// if you read it after evaluating a subexpression `X`, the value
593 /// you get indicates whether any subexpression that was
594 /// evaluating up to and including `X` diverged.
596 /// We currently use this flag only for diagnostic purposes:
598 /// - To warn about unreachable code: if, after processing a
599 /// sub-expression but before we have applied the effects of the
600 /// current node, we see that the flag is set to `Always`, we
601 /// can issue a warning. This corresponds to something like
602 /// `foo(return)`; we warn on the `foo()` expression. (We then
603 /// update the flag to `WarnedAlways` to suppress duplicate
604 /// reports.) Similarly, if we traverse to a fresh statement (or
605 /// tail expression) from a `Always` setting, we will issue a
606 /// warning. This corresponds to something like `{return;
607 /// foo();}` or `{return; 22}`, where we would warn on the
610 /// An expression represents dead code if, after checking it,
611 /// the diverges flag is set to something other than `Maybe`.
612 diverges: Cell<Diverges>,
614 /// Whether any child nodes have any type errors.
615 has_errors: Cell<bool>,
617 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
619 inh: &'a Inherited<'a, 'tcx>,
622 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
623 type Target = Inherited<'a, 'tcx>;
624 fn deref(&self) -> &Self::Target {
629 /// Helper type of a temporary returned by `Inherited::build(...)`.
630 /// Necessary because we can't write the following bound:
631 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
632 pub struct InheritedBuilder<'tcx> {
633 infcx: infer::InferCtxtBuilder<'tcx>,
637 impl Inherited<'_, 'tcx> {
638 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
639 let hir_id_root = if def_id.is_local() {
640 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
641 DefId::local(hir_id.owner)
647 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
653 impl<'tcx> InheritedBuilder<'tcx> {
654 fn enter<F, R>(&mut self, f: F) -> R
656 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
658 let def_id = self.def_id;
659 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
663 impl Inherited<'a, 'tcx> {
664 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
666 let item_id = tcx.hir().as_local_hir_id(def_id);
667 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
668 let implicit_region_bound = body_id.map(|body_id| {
669 let body = tcx.hir().body(body_id);
670 tcx.mk_region(ty::ReScope(region::Scope {
671 id: body.value.hir_id.local_id,
672 data: region::ScopeData::CallSite,
677 tables: MaybeInProgressTables { maybe_tables: infcx.in_progress_tables },
679 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
680 locals: RefCell::new(Default::default()),
681 deferred_sized_obligations: RefCell::new(Vec::new()),
682 deferred_call_resolutions: RefCell::new(Default::default()),
683 deferred_cast_checks: RefCell::new(Vec::new()),
684 deferred_generator_interiors: RefCell::new(Vec::new()),
685 opaque_types: RefCell::new(Default::default()),
686 opaque_types_vars: RefCell::new(Default::default()),
687 implicit_region_bound,
692 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
693 debug!("register_predicate({:?})", obligation);
694 if obligation.has_escaping_bound_vars() {
695 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
697 self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
700 fn register_predicates<I>(&self, obligations: I)
702 I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
704 for obligation in obligations {
705 self.register_predicate(obligation);
709 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
710 self.register_predicates(infer_ok.obligations);
714 fn normalize_associated_types_in<T>(
718 param_env: ty::ParamEnv<'tcx>,
722 T: TypeFoldable<'tcx>,
724 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
725 self.register_infer_ok_obligations(ok)
729 struct CheckItemTypesVisitor<'tcx> {
733 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
734 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
735 check_item_type(self.tcx, i);
737 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
738 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
741 pub fn check_wf_new(tcx: TyCtxt<'_>) {
742 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
743 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
746 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
747 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
750 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
751 debug_assert!(crate_num == LOCAL_CRATE);
752 tcx.par_body_owners(|body_owner_def_id| {
753 tcx.ensure().typeck_tables_of(body_owner_def_id);
757 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
758 wfcheck::check_item_well_formed(tcx, def_id);
761 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
762 wfcheck::check_trait_item(tcx, def_id);
765 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
766 wfcheck::check_impl_item(tcx, def_id);
769 pub fn provide(providers: &mut Providers<'_>) {
770 method::provide(providers);
771 *providers = Providers {
774 diagnostic_only_typeck_tables_of,
778 check_item_well_formed,
779 check_trait_item_well_formed,
780 check_impl_item_well_formed,
781 check_mod_item_types,
786 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
787 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
790 /// If this `DefId` is a "primary tables entry", returns
791 /// `Some((body_id, header, decl))` with information about
792 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
795 /// If this function returns `Some`, then `typeck_tables(def_id)` will
796 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
797 /// may not succeed. In some cases where this function returns `None`
798 /// (notably closures), `typeck_tables(def_id)` would wind up
799 /// redirecting to the owning function.
803 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
804 match tcx.hir().get(id) {
805 Node::Item(item) => match item.kind {
806 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
807 Some((body, Some(ty), None, None))
809 hir::ItemKind::Fn(ref sig, .., body) => {
810 Some((body, None, Some(&sig.header), Some(&sig.decl)))
814 Node::TraitItem(item) => match item.kind {
815 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
816 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) => {
817 Some((body, None, Some(&sig.header), Some(&sig.decl)))
821 Node::ImplItem(item) => match item.kind {
822 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
823 hir::ImplItemKind::Method(ref sig, body) => {
824 Some((body, None, Some(&sig.header), Some(&sig.decl)))
828 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
833 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
834 // Closures' tables come from their outermost function,
835 // as they are part of the same "inference environment".
836 let outer_def_id = tcx.closure_base_def_id(def_id);
837 if outer_def_id != def_id {
838 return tcx.has_typeck_tables(outer_def_id);
841 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
842 primary_body_of(tcx, id).is_some()
845 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
846 &*tcx.typeck_tables_of(def_id).used_trait_imports
849 /// Inspects the substs of opaque types, replacing any inference variables
850 /// with proper generic parameter from the identity substs.
852 /// This is run after we normalize the function signature, to fix any inference
853 /// variables introduced by the projection of associated types. This ensures that
854 /// any opaque types used in the signature continue to refer to generic parameters,
855 /// allowing them to be considered for defining uses in the function body
857 /// For example, consider this code.
862 /// fn use_it(self) -> Self::MyItem
864 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
865 /// type MyItem = impl Iterator<Item = I>;
866 /// fn use_it(self) -> Self::MyItem {
872 /// When we normalize the signature of `use_it` from the impl block,
873 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
874 /// However, this projection result may contain inference variables, due
875 /// to the way that projection works. We didn't have any inference variables
876 /// in the signature to begin with - leaving them in will cause us to incorrectly
877 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
878 /// variables back to the actual generic parameters, we will correctly see that
879 /// we have a defining use of `MyItem`
880 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
882 T: TypeFoldable<'tcx>,
884 struct FixupFolder<'tcx> {
888 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
889 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
893 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
895 ty::Opaque(def_id, substs) => {
896 debug!("fixup_opaque_types: found type {:?}", ty);
897 // Here, we replace any inference variables that occur within
898 // the substs of an opaque type. By definition, any type occuring
899 // in the substs has a corresponding generic parameter, which is what
900 // we replace it with.
901 // This replacement is only run on the function signature, so any
902 // inference variables that we come across must be the rust of projection
903 // (there's no other way for a user to get inference variables into
904 // a function signature).
905 if ty.needs_infer() {
906 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
907 let old_param = substs[param.index as usize];
908 match old_param.unpack() {
909 GenericArgKind::Type(old_ty) => {
910 if let ty::Infer(_) = old_ty.kind {
911 // Replace inference type with a generic parameter
912 self.tcx.mk_param_from_def(param)
914 old_param.fold_with(self)
917 GenericArgKind::Const(old_const) => {
918 if let ty::ConstKind::Infer(_) = old_const.val {
919 // This should never happen - we currently do not support
920 // 'const projections', e.g.:
921 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
922 // which should be the only way for us to end up with a const inference
923 // variable after projection. If Rust ever gains support for this kind
924 // of projection, this should *probably* be changed to
925 // `self.tcx.mk_param_from_def(param)`
927 "Found infer const: `{:?}` in opaque type: {:?}",
932 old_param.fold_with(self)
935 GenericArgKind::Lifetime(old_region) => {
936 if let RegionKind::ReVar(_) = old_region {
937 self.tcx.mk_param_from_def(param)
939 old_param.fold_with(self)
944 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
945 debug!("fixup_opaque_types: new type: {:?}", new_ty);
951 _ => ty.super_fold_with(self),
956 debug!("fixup_opaque_types({:?})", val);
957 val.fold_with(&mut FixupFolder { tcx })
960 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &ty::TypeckTables<'tcx> {
961 let fallback = move || tcx.type_of(def_id);
962 typeck_tables_of_with_fallback(tcx, def_id, fallback)
965 /// Used only to get `TypeckTables` for type inference during error recovery.
966 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
967 fn diagnostic_only_typeck_tables_of<'tcx>(
970 ) -> &ty::TypeckTables<'tcx> {
971 assert!(def_id.is_local());
972 let fallback = move || {
973 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id).unwrap());
974 tcx.sess.delay_span_bug(span, "diagnostic only typeck table used");
977 typeck_tables_of_with_fallback(tcx, def_id, fallback)
980 fn typeck_tables_of_with_fallback<'tcx>(
983 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
984 ) -> &'tcx ty::TypeckTables<'tcx> {
985 // Closures' tables come from their outermost function,
986 // as they are part of the same "inference environment".
987 let outer_def_id = tcx.closure_base_def_id(def_id);
988 if outer_def_id != def_id {
989 return tcx.typeck_tables_of(outer_def_id);
992 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
993 let span = tcx.hir().span(id);
995 // Figure out what primary body this item has.
996 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
997 span_bug!(span, "can't type-check body of {:?}", def_id);
999 let body = tcx.hir().body(body_id);
1001 let tables = Inherited::build(tcx, def_id).enter(|inh| {
1002 let param_env = tcx.param_env(def_id);
1003 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
1004 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
1005 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1006 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl, &[], None)
1011 check_abi(tcx, span, fn_sig.abi());
1013 // Compute the fty from point of view of inside the fn.
1014 let fn_sig = tcx.liberate_late_bound_regions(def_id, &fn_sig);
1015 let fn_sig = inh.normalize_associated_types_in(
1022 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1024 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1027 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1028 let expected_type = body_ty
1029 .and_then(|ty| match ty.kind {
1030 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1033 .unwrap_or_else(fallback);
1034 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1035 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1037 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1038 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1043 // Gather locals in statics (because of block expressions).
1044 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1046 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1048 fcx.write_ty(id, revealed_ty);
1053 // All type checking constraints were added, try to fallback unsolved variables.
1054 fcx.select_obligations_where_possible(false, |_| {});
1055 let mut fallback_has_occurred = false;
1057 // We do fallback in two passes, to try to generate
1058 // better error messages.
1059 // The first time, we do *not* replace opaque types.
1060 for ty in &fcx.unsolved_variables() {
1061 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1063 // We now see if we can make progress. This might
1064 // cause us to unify inference variables for opaque types,
1065 // since we may have unified some other type variables
1066 // during the first phase of fallback.
1067 // This means that we only replace inference variables with their underlying
1068 // opaque types as a last resort.
1070 // In code like this:
1073 // type MyType = impl Copy;
1074 // fn produce() -> MyType { true }
1075 // fn bad_produce() -> MyType { panic!() }
1078 // we want to unify the opaque inference variable in `bad_produce`
1079 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1080 // This will produce a nice error message about conflicting concrete
1081 // types for `MyType`.
1083 // If we had tried to fallback the opaque inference variable to `MyType`,
1084 // we will generate a confusing type-check error that does not explicitly
1085 // refer to opaque types.
1086 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1088 // We now run fallback again, but this time we allow it to replace
1089 // unconstrained opaque type variables, in addition to performing
1090 // other kinds of fallback.
1091 for ty in &fcx.unsolved_variables() {
1092 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1095 // See if we can make any more progress.
1096 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1098 // Even though coercion casts provide type hints, we check casts after fallback for
1099 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1102 // Closure and generator analysis may run after fallback
1103 // because they don't constrain other type variables.
1104 fcx.closure_analyze(body);
1105 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1106 fcx.resolve_generator_interiors(def_id);
1108 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1109 let ty = fcx.normalize_ty(span, ty);
1110 fcx.require_type_is_sized(ty, span, code);
1113 fcx.select_all_obligations_or_error();
1115 if fn_decl.is_some() {
1116 fcx.regionck_fn(id, body);
1118 fcx.regionck_expr(body);
1121 fcx.resolve_type_vars_in_body(body)
1124 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1125 // it will need to hold.
1126 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
1131 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1132 if !tcx.sess.target.target.is_abi_supported(abi) {
1137 "The ABI `{}` is not supported for the current target",
1144 struct GatherLocalsVisitor<'a, 'tcx> {
1145 fcx: &'a FnCtxt<'a, 'tcx>,
1146 parent_id: hir::HirId,
1149 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1150 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1153 // infer the variable's type
1154 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1155 kind: TypeVariableOriginKind::TypeInference,
1161 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1165 // take type that the user specified
1166 self.fcx.locals.borrow_mut().insert(nid, typ);
1173 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1174 type Map = Map<'tcx>;
1176 fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
1177 NestedVisitorMap::None
1180 // Add explicitly-declared locals.
1181 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1182 let local_ty = match local.ty {
1184 let o_ty = self.fcx.to_ty(&ty);
1186 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1187 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1196 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1198 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1199 ty.hir_id, o_ty, revealed_ty, c_ty
1201 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1203 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1207 self.assign(local.span, local.hir_id, local_ty);
1210 "local variable {:?} is assigned type {}",
1213 .ty_to_string(self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty)
1215 intravisit::walk_local(self, local);
1218 // Add pattern bindings.
1219 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1220 if let PatKind::Binding(_, _, ident, _) = p.kind {
1221 let var_ty = self.assign(p.span, p.hir_id, None);
1223 if !self.fcx.tcx.features().unsized_locals {
1224 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1228 "pattern binding {} is assigned to {} with type {:?}",
1231 .ty_to_string(self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1235 intravisit::walk_pat(self, p);
1238 // Don't descend into the bodies of nested closures
1241 _: intravisit::FnKind<'tcx>,
1242 _: &'tcx hir::FnDecl<'tcx>,
1250 /// When `check_fn` is invoked on a generator (i.e., a body that
1251 /// includes yield), it returns back some information about the yield
1253 struct GeneratorTypes<'tcx> {
1254 /// Type of value that is yielded.
1257 /// Types that are captured (see `GeneratorInterior` for more).
1260 /// Indicates if the generator is movable or static (immovable).
1261 movability: hir::Movability,
1264 /// Helper used for fns and closures. Does the grungy work of checking a function
1265 /// body and returns the function context used for that purpose, since in the case of a fn item
1266 /// there is still a bit more to do.
1269 /// * inherited: other fields inherited from the enclosing fn (if any)
1270 fn check_fn<'a, 'tcx>(
1271 inherited: &'a Inherited<'a, 'tcx>,
1272 param_env: ty::ParamEnv<'tcx>,
1273 fn_sig: ty::FnSig<'tcx>,
1274 decl: &'tcx hir::FnDecl<'tcx>,
1276 body: &'tcx hir::Body<'tcx>,
1277 can_be_generator: Option<hir::Movability>,
1278 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1279 let mut fn_sig = fn_sig.clone();
1281 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1283 // Create the function context. This is either derived from scratch or,
1284 // in the case of closures, based on the outer context.
1285 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1286 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1289 let sess = tcx.sess;
1290 let hir = tcx.hir();
1292 let declared_ret_ty = fn_sig.output();
1293 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1294 let revealed_ret_ty =
1295 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1296 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1297 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1298 fn_sig = tcx.mk_fn_sig(
1299 fn_sig.inputs().iter().cloned(),
1306 let span = body.value.span;
1308 fn_maybe_err(tcx, span, fn_sig.abi);
1310 if body.generator_kind.is_some() && can_be_generator.is_some() {
1312 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1313 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1314 fcx.yield_ty = Some(yield_ty);
1317 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id));
1318 let outer_hir_id = hir.as_local_hir_id(outer_def_id).unwrap();
1319 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1321 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1322 // (as it's created inside the body itself, not passed in from outside).
1323 let maybe_va_list = if fn_sig.c_variadic {
1324 let va_list_did = tcx.require_lang_item(
1325 lang_items::VaListTypeLangItem,
1326 Some(body.params.last().unwrap().span),
1328 let region = tcx.mk_region(ty::ReScope(region::Scope {
1329 id: body.value.hir_id.local_id,
1330 data: region::ScopeData::CallSite,
1333 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1338 // Add formal parameters.
1339 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1340 let inputs_fn = fn_sig.inputs().iter().copied();
1341 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1342 // Check the pattern.
1343 fcx.check_pat_top(¶m.pat, param_ty, try { inputs_hir?.get(idx)?.span }, false);
1345 // Check that argument is Sized.
1346 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1347 // for simple cases like `fn foo(x: Trait)`,
1348 // where we would error once on the parameter as a whole, and once on the binding `x`.
1349 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1350 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1353 fcx.write_ty(param.hir_id, param_ty);
1356 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1358 fcx.check_return_expr(&body.value);
1360 // We insert the deferred_generator_interiors entry after visiting the body.
1361 // This ensures that all nested generators appear before the entry of this generator.
1362 // resolve_generator_interiors relies on this property.
1363 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1365 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1366 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1367 Some(GeneratorTypes {
1368 yield_ty: fcx.yield_ty.unwrap(),
1370 movability: can_be_generator.unwrap(),
1376 // Finalize the return check by taking the LUB of the return types
1377 // we saw and assigning it to the expected return type. This isn't
1378 // really expected to fail, since the coercions would have failed
1379 // earlier when trying to find a LUB.
1381 // However, the behavior around `!` is sort of complex. In the
1382 // event that the `actual_return_ty` comes back as `!`, that
1383 // indicates that the fn either does not return or "returns" only
1384 // values of type `!`. In this case, if there is an expected
1385 // return type that is *not* `!`, that should be ok. But if the
1386 // return type is being inferred, we want to "fallback" to `!`:
1388 // let x = move || panic!();
1390 // To allow for that, I am creating a type variable with diverging
1391 // fallback. This was deemed ever so slightly better than unifying
1392 // the return value with `!` because it allows for the caller to
1393 // make more assumptions about the return type (e.g., they could do
1395 // let y: Option<u32> = Some(x());
1397 // which would then cause this return type to become `u32`, not
1399 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1400 let mut actual_return_ty = coercion.complete(&fcx);
1401 if actual_return_ty.is_never() {
1402 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1403 kind: TypeVariableOriginKind::DivergingFn,
1407 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1409 // Check that the main return type implements the termination trait.
1410 if let Some(term_id) = tcx.lang_items().termination() {
1411 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1412 let main_id = hir.as_local_hir_id(def_id).unwrap();
1413 if main_id == fn_id {
1414 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1415 let trait_ref = ty::TraitRef::new(term_id, substs);
1416 let return_ty_span = decl.output.span();
1417 let cause = traits::ObligationCause::new(
1420 ObligationCauseCode::MainFunctionType,
1423 inherited.register_predicate(traits::Obligation::new(
1426 trait_ref.to_predicate(),
1432 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1433 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1434 if panic_impl_did == hir.local_def_id(fn_id) {
1435 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1436 if declared_ret_ty.kind != ty::Never {
1437 sess.span_err(decl.output.span(), "return type should be `!`");
1440 let inputs = fn_sig.inputs();
1441 let span = hir.span(fn_id);
1442 if inputs.len() == 1 {
1443 let arg_is_panic_info = match inputs[0].kind {
1444 ty::Ref(region, ty, mutbl) => match ty.kind {
1445 ty::Adt(ref adt, _) => {
1446 adt.did == panic_info_did
1447 && mutbl == hir::Mutability::Not
1448 && *region != RegionKind::ReStatic
1455 if !arg_is_panic_info {
1456 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1459 if let Node::Item(item) = hir.get(fn_id) {
1460 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1461 if !generics.params.is_empty() {
1462 sess.span_err(span, "should have no type parameters");
1467 let span = sess.source_map().def_span(span);
1468 sess.span_err(span, "function should have one argument");
1471 sess.err("language item required, but not found: `panic_info`");
1476 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1477 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1478 if alloc_error_handler_did == hir.local_def_id(fn_id) {
1479 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1480 if declared_ret_ty.kind != ty::Never {
1481 sess.span_err(decl.output.span(), "return type should be `!`");
1484 let inputs = fn_sig.inputs();
1485 let span = hir.span(fn_id);
1486 if inputs.len() == 1 {
1487 let arg_is_alloc_layout = match inputs[0].kind {
1488 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1492 if !arg_is_alloc_layout {
1493 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1496 if let Node::Item(item) = hir.get(fn_id) {
1497 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1498 if !generics.params.is_empty() {
1501 "`#[alloc_error_handler]` function should have no type \
1508 let span = sess.source_map().def_span(span);
1509 sess.span_err(span, "function should have one argument");
1512 sess.err("language item required, but not found: `alloc_layout`");
1520 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1521 let def_id = tcx.hir().local_def_id(id);
1522 let def = tcx.adt_def(def_id);
1523 def.destructor(tcx); // force the destructor to be evaluated
1524 check_representable(tcx, span, def_id);
1526 if def.repr.simd() {
1527 check_simd(tcx, span, def_id);
1530 check_transparent(tcx, span, def_id);
1531 check_packed(tcx, span, def_id);
1534 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1535 let def_id = tcx.hir().local_def_id(id);
1536 let def = tcx.adt_def(def_id);
1537 def.destructor(tcx); // force the destructor to be evaluated
1538 check_representable(tcx, span, def_id);
1539 check_transparent(tcx, span, def_id);
1540 check_union_fields(tcx, span, def_id);
1541 check_packed(tcx, span, def_id);
1544 /// When the `#![feature(untagged_unions)]` gate is active,
1545 /// check that the fields of the `union` does not contain fields that need dropping.
1546 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1547 let item_type = tcx.type_of(item_def_id);
1548 if let ty::Adt(def, substs) = item_type.kind {
1549 assert!(def.is_union());
1550 let fields = &def.non_enum_variant().fields;
1551 for field in fields {
1552 let field_ty = field.ty(tcx, substs);
1553 // We are currently checking the type this field came from, so it must be local.
1554 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1555 let param_env = tcx.param_env(field.did);
1556 if field_ty.needs_drop(tcx, param_env) {
1561 "unions may not contain fields that need dropping"
1563 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1569 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1574 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1575 /// projections that would result in "inheriting lifetimes".
1576 fn check_opaque<'tcx>(
1579 substs: SubstsRef<'tcx>,
1581 origin: &hir::OpaqueTyOrigin,
1583 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1584 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1587 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1588 /// in "inheriting lifetimes".
1589 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: Span) {
1591 tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1593 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1598 struct ProhibitOpaqueVisitor<'tcx> {
1599 opaque_identity_ty: Ty<'tcx>,
1600 generics: &'tcx ty::Generics,
1603 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1604 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1605 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1606 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1609 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1610 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1611 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1612 return *index < self.generics.parent_count as u32;
1615 r.super_visit_with(self)
1619 let prohibit_opaque = match item.kind {
1620 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. })
1621 | ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1622 let mut visitor = ProhibitOpaqueVisitor {
1623 opaque_identity_ty: tcx
1624 .mk_opaque(def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1625 generics: tcx.generics_of(def_id),
1627 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1629 tcx.predicates_of(def_id)
1632 .any(|(predicate, _)| predicate.visit_with(&mut visitor))
1637 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1638 if prohibit_opaque {
1639 let is_async = match item.kind {
1640 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1641 hir::OpaqueTyOrigin::AsyncFn => true,
1644 _ => unreachable!(),
1647 tcx.sess.span_err(span, &format!(
1648 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1650 if is_async { "async fn" } else { "impl Trait" },
1655 /// Checks that an opaque type does not contain cycles.
1656 fn check_opaque_for_cycles<'tcx>(
1659 substs: SubstsRef<'tcx>,
1661 origin: &hir::OpaqueTyOrigin,
1663 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1664 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1665 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",)
1666 .span_label(span, "recursive `async fn`")
1667 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`")
1671 struct_span_err!(tcx.sess, span, E0720, "opaque type expands to a recursive type",);
1672 err.span_label(span, "expands to a recursive type");
1673 if let ty::Opaque(..) = partially_expanded_type.kind {
1674 err.note("type resolves to itself");
1676 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1683 // Forbid defining intrinsics in Rust code,
1684 // as they must always be defined by the compiler.
1685 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1686 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1687 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1691 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1693 "check_item_type(it.hir_id={}, it.name={})",
1695 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1697 let _indenter = indenter();
1699 // Consts can play a role in type-checking, so they are included here.
1700 hir::ItemKind::Static(..) => {
1701 let def_id = tcx.hir().local_def_id(it.hir_id);
1702 tcx.typeck_tables_of(def_id);
1703 maybe_check_static_with_link_section(tcx, def_id, it.span);
1705 hir::ItemKind::Const(..) => {
1706 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1708 hir::ItemKind::Enum(ref enum_definition, _) => {
1709 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1711 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1712 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1713 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1714 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1715 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1716 check_impl_items_against_trait(
1723 let trait_def_id = impl_trait_ref.def_id;
1724 check_on_unimplemented(tcx, trait_def_id, it);
1727 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1728 let def_id = tcx.hir().local_def_id(it.hir_id);
1729 check_on_unimplemented(tcx, def_id, it);
1731 for item in items.iter() {
1732 let item = tcx.hir().trait_item(item.id);
1733 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1734 let abi = sig.header.abi;
1735 fn_maybe_err(tcx, item.ident.span, abi);
1739 hir::ItemKind::Struct(..) => {
1740 check_struct(tcx, it.hir_id, it.span);
1742 hir::ItemKind::Union(..) => {
1743 check_union(tcx, it.hir_id, it.span);
1745 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1746 let def_id = tcx.hir().local_def_id(it.hir_id);
1748 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1749 check_opaque(tcx, def_id, substs, it.span, &origin);
1751 hir::ItemKind::TyAlias(..) => {
1752 let def_id = tcx.hir().local_def_id(it.hir_id);
1753 let pty_ty = tcx.type_of(def_id);
1754 let generics = tcx.generics_of(def_id);
1755 check_bounds_are_used(tcx, &generics, pty_ty);
1757 hir::ItemKind::ForeignMod(ref m) => {
1758 check_abi(tcx, it.span, m.abi);
1760 if m.abi == Abi::RustIntrinsic {
1761 for item in m.items {
1762 intrinsic::check_intrinsic_type(tcx, item);
1764 } else if m.abi == Abi::PlatformIntrinsic {
1765 for item in m.items {
1766 intrinsic::check_platform_intrinsic_type(tcx, item);
1769 for item in m.items {
1770 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1771 let own_counts = generics.own_counts();
1772 if generics.params.len() - own_counts.lifetimes != 0 {
1773 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1774 (_, 0) => ("type", "types", Some("u32")),
1775 // We don't specify an example value, because we can't generate
1776 // a valid value for any type.
1777 (0, _) => ("const", "consts", None),
1778 _ => ("type or const", "types or consts", None),
1784 "foreign items may not have {} parameters",
1787 .span_label(item.span, &format!("can't have {} parameters", kinds))
1789 // FIXME: once we start storing spans for type arguments, turn this
1790 // into a suggestion.
1792 "replace the {} parameters with concrete {}{}",
1795 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1801 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1802 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1807 _ => { /* nothing to do */ }
1811 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1812 // Only restricted on wasm32 target for now
1813 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1817 // If `#[link_section]` is missing, then nothing to verify
1818 let attrs = tcx.codegen_fn_attrs(id);
1819 if attrs.link_section.is_none() {
1823 // For the wasm32 target statics with `#[link_section]` are placed into custom
1824 // sections of the final output file, but this isn't link custom sections of
1825 // other executable formats. Namely we can only embed a list of bytes,
1826 // nothing with pointers to anything else or relocations. If any relocation
1827 // show up, reject them here.
1828 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1829 // the consumer's responsibility to ensure all bytes that have been read
1830 // have defined values.
1831 if let Ok(static_) = tcx.const_eval_poly(id) {
1832 let alloc = if let ty::ConstKind::Value(ConstValue::ByRef { alloc, .. }) = static_.val {
1835 bug!("Matching on non-ByRef static")
1837 if alloc.relocations().len() != 0 {
1838 let msg = "statics with a custom `#[link_section]` must be a \
1839 simple list of bytes on the wasm target with no \
1840 extra levels of indirection such as references";
1841 tcx.sess.span_err(span, msg);
1846 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1847 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1848 // an error would be reported if this fails.
1849 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1852 fn report_forbidden_specialization(
1854 impl_item: &hir::ImplItem<'_>,
1857 let mut err = struct_span_err!(
1861 "`{}` specializes an item from a parent `impl`, but \
1862 that item is not marked `default`",
1865 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
1867 match tcx.span_of_impl(parent_impl) {
1869 err.span_label(span, "parent `impl` is here");
1871 "to specialize, `{}` in the parent `impl` must be marked `default`",
1876 err.note(&format!("parent implementation is in crate `{}`", cname));
1883 fn check_specialization_validity<'tcx>(
1885 trait_def: &ty::TraitDef,
1886 trait_item: &ty::AssocItem,
1888 impl_item: &hir::ImplItem<'_>,
1890 let kind = match impl_item.kind {
1891 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1892 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1893 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1894 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1897 let mut ancestor_impls = trait_def
1898 .ancestors(tcx, impl_id)
1900 .filter_map(|parent| {
1901 if parent.is_from_trait() {
1904 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1909 if ancestor_impls.peek().is_none() {
1910 // No parent, nothing to specialize.
1914 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1916 // Parent impl exists, and contains the parent item we're trying to specialize, but
1917 // doesn't mark it `default`.
1918 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1919 Some(Err(parent_impl.def_id()))
1922 // Parent impl contains item and makes it specializable.
1923 Some(_) => Some(Ok(())),
1925 // Parent impl doesn't mention the item. This means it's inherited from the
1926 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1927 // "defaultness" from the grandparent, else they are final.
1929 if traits::impl_is_default(tcx, parent_impl.def_id()) {
1932 Some(Err(parent_impl.def_id()))
1938 // If `opt_result` is `None`, we have only encoutered `default impl`s that don't contain the
1939 // item. This is allowed, the item isn't actually getting specialized here.
1940 let result = opt_result.unwrap_or(Ok(()));
1942 if let Err(parent_impl) = result {
1943 report_forbidden_specialization(tcx, impl_item, parent_impl);
1947 fn check_impl_items_against_trait<'tcx>(
1949 full_impl_span: Span,
1951 impl_trait_ref: ty::TraitRef<'tcx>,
1952 impl_item_refs: &[hir::ImplItemRef<'_>],
1954 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1956 // If the trait reference itself is erroneous (so the compilation is going
1957 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1958 // isn't populated for such impls.
1959 if impl_trait_ref.references_error() {
1963 // Locate trait definition and items
1964 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1965 let mut overridden_associated_type = None;
1967 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1969 // Check existing impl methods to see if they are both present in trait
1970 // and compatible with trait signature
1971 for impl_item in impl_items() {
1972 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
1973 let ty_trait_item = tcx
1974 .associated_items(impl_trait_ref.def_id)
1976 Namespace::from(&impl_item.kind) == Namespace::from(ac.kind)
1977 && tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id)
1980 // Not compatible, but needed for the error message
1981 tcx.associated_items(impl_trait_ref.def_id)
1982 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1985 // Check that impl definition matches trait definition
1986 if let Some(ty_trait_item) = ty_trait_item {
1987 match impl_item.kind {
1988 hir::ImplItemKind::Const(..) => {
1989 // Find associated const definition.
1990 if ty_trait_item.kind == ty::AssocKind::Const {
1999 let mut err = struct_span_err!(
2003 "item `{}` is an associated const, \
2004 which doesn't match its trait `{}`",
2006 impl_trait_ref.print_only_trait_path()
2008 err.span_label(impl_item.span, "does not match trait");
2009 // We can only get the spans from local trait definition
2010 // Same for E0324 and E0325
2011 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2012 err.span_label(trait_span, "item in trait");
2017 hir::ImplItemKind::Method(..) => {
2018 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2019 if ty_trait_item.kind == ty::AssocKind::Method {
2020 compare_impl_method(
2029 let mut err = struct_span_err!(
2033 "item `{}` is an associated method, \
2034 which doesn't match its trait `{}`",
2036 impl_trait_ref.print_only_trait_path()
2038 err.span_label(impl_item.span, "does not match trait");
2039 if let Some(trait_span) = opt_trait_span {
2040 err.span_label(trait_span, "item in trait");
2045 hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {
2046 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2047 if ty_trait_item.kind == ty::AssocKind::Type {
2048 if ty_trait_item.defaultness.has_value() {
2049 overridden_associated_type = Some(impl_item);
2060 let mut err = struct_span_err!(
2064 "item `{}` is an associated type, \
2065 which doesn't match its trait `{}`",
2067 impl_trait_ref.print_only_trait_path()
2069 err.span_label(impl_item.span, "does not match trait");
2070 if let Some(trait_span) = opt_trait_span {
2071 err.span_label(trait_span, "item in trait");
2078 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2082 // Check for missing items from trait
2083 let mut missing_items = Vec::new();
2084 let mut invalidated_items = Vec::new();
2085 let associated_type_overridden = overridden_associated_type.is_some();
2086 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
2087 let is_implemented = trait_def
2088 .ancestors(tcx, impl_id)
2089 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2090 .map(|node_item| !node_item.node.is_from_trait())
2093 if !is_implemented && !traits::impl_is_default(tcx, impl_id) {
2094 if !trait_item.defaultness.has_value() {
2095 missing_items.push(trait_item);
2096 } else if associated_type_overridden {
2097 invalidated_items.push(trait_item.ident);
2102 if !missing_items.is_empty() {
2103 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2106 if !invalidated_items.is_empty() {
2107 let invalidator = overridden_associated_type.unwrap();
2112 "the following trait items need to be reimplemented as `{}` was overridden: `{}`",
2114 invalidated_items.iter().map(|name| name.to_string()).collect::<Vec<_>>().join("`, `")
2120 fn missing_items_err(
2123 missing_items: &[ty::AssocItem],
2124 full_impl_span: Span,
2126 let missing_items_msg = missing_items
2128 .map(|trait_item| trait_item.ident.to_string())
2129 .collect::<Vec<_>>()
2132 let mut err = struct_span_err!(
2136 "not all trait items implemented, missing: `{}`",
2139 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2141 // `Span` before impl block closing brace.
2142 let hi = full_impl_span.hi() - BytePos(1);
2143 // Point at the place right before the closing brace of the relevant `impl` to suggest
2144 // adding the associated item at the end of its body.
2145 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2146 // Obtain the level of indentation ending in `sugg_sp`.
2147 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2148 // Make the whitespace that will make the suggestion have the right indentation.
2149 let padding: String = (0..indentation).map(|_| " ").collect();
2151 for trait_item in missing_items {
2152 let snippet = suggestion_signature(&trait_item, tcx);
2153 let code = format!("{}{}\n{}", padding, snippet, padding);
2154 let msg = format!("implement the missing item: `{}`", snippet);
2155 let appl = Applicability::HasPlaceholders;
2156 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2157 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2158 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2160 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2166 /// Return placeholder code for the given function.
2167 fn fn_sig_suggestion(sig: &ty::FnSig<'_>, ident: Ident) -> String {
2172 Some(match ty.kind {
2173 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2174 ty::Ref(reg, ref_ty, mutability) => {
2175 let reg = match &format!("{}", reg)[..] {
2176 "'_" | "" => String::new(),
2177 reg => format!("{} ", reg),
2180 ty::Param(param) if param.name == kw::SelfUpper => {
2181 format!("&{}{}self", reg, mutability.prefix_str())
2183 _ => format!("_: {:?}", ty),
2186 _ => format!("_: {:?}", ty),
2189 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2190 .filter_map(|arg| arg)
2191 .collect::<Vec<String>>()
2193 let output = sig.output();
2194 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2196 let unsafety = sig.unsafety.prefix_str();
2197 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2198 // not be present in the `fn` definition, not will we account for renamed
2199 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2200 // fill in a significant portion of the missing code, and other subsequent
2201 // suggestions can help the user fix the code.
2202 format!("{}fn {}({}){} {{ unimplemented!() }}", unsafety, ident, args, output)
2205 /// Return placeholder code for the given associated item.
2206 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2207 /// structured suggestion.
2208 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2210 ty::AssocKind::Method => {
2211 // We skip the binder here because the binder would deanonymize all
2212 // late-bound regions, and we don't want method signatures to show up
2213 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2214 // regions just fine, showing `fn(&MyType)`.
2215 fn_sig_suggestion(tcx.fn_sig(assoc.def_id).skip_binder(), assoc.ident)
2217 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2218 // FIXME(type_alias_impl_trait): we should print bounds here too.
2219 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2220 ty::AssocKind::Const => {
2221 let ty = tcx.type_of(assoc.def_id);
2222 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2223 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2228 /// Checks whether a type can be represented in memory. In particular, it
2229 /// identifies types that contain themselves without indirection through a
2230 /// pointer, which would mean their size is unbounded.
2231 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2232 let rty = tcx.type_of(item_def_id);
2234 // Check that it is possible to represent this type. This call identifies
2235 // (1) types that contain themselves and (2) types that contain a different
2236 // recursive type. It is only necessary to throw an error on those that
2237 // contain themselves. For case 2, there must be an inner type that will be
2238 // caught by case 1.
2239 match rty.is_representable(tcx, sp) {
2240 Representability::SelfRecursive(spans) => {
2241 let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id);
2243 err.span_label(span, "recursive without indirection");
2248 Representability::Representable | Representability::ContainsRecursive => (),
2253 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2254 let t = tcx.type_of(def_id);
2255 if let ty::Adt(def, substs) = t.kind {
2256 if def.is_struct() {
2257 let fields = &def.non_enum_variant().fields;
2258 if fields.is_empty() {
2259 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2262 let e = fields[0].ty(tcx, substs);
2263 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2264 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2265 .span_label(sp, "SIMD elements must have the same type")
2270 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2271 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2277 "SIMD vector element type should be machine type"
2287 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2288 let repr = tcx.adt_def(def_id).repr;
2290 for attr in tcx.get_attrs(def_id).iter() {
2291 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2292 if let attr::ReprPacked(pack) = r {
2293 if let Some(repr_pack) = repr.pack {
2294 if pack as u64 != repr_pack.bytes() {
2299 "type has conflicting packed representation hints"
2307 if repr.align.is_some() {
2312 "type has conflicting packed and align representation hints"
2315 } else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
2320 "packed type cannot transitively contain a `[repr(align)]` type"
2327 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
2328 let t = tcx.type_of(def_id);
2329 if stack.contains(&def_id) {
2330 debug!("check_packed_inner: {:?} is recursive", t);
2333 if let ty::Adt(def, substs) = t.kind {
2334 if def.is_struct() || def.is_union() {
2335 if tcx.adt_def(def.did).repr.align.is_some() {
2338 // push struct def_id before checking fields
2340 for field in &def.non_enum_variant().fields {
2341 let f = field.ty(tcx, substs);
2342 if let ty::Adt(def, _) = f.kind {
2343 if check_packed_inner(tcx, def.did, stack) {
2348 // only need to pop if not early out
2355 /// Emit an error when encountering more or less than one variant in a transparent enum.
2356 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2357 let variant_spans: Vec<_> = adt
2360 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2362 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2363 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2364 err.span_label(sp, &msg);
2365 if let [start @ .., end] = &*variant_spans {
2366 for variant_span in start {
2367 err.span_label(*variant_span, "");
2369 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2374 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2376 fn bad_non_zero_sized_fields<'tcx>(
2378 adt: &'tcx ty::AdtDef,
2380 field_spans: impl Iterator<Item = Span>,
2383 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2384 let mut err = struct_span_err!(
2388 "{}transparent {} {}",
2389 if adt.is_enum() { "the variant of a " } else { "" },
2393 err.span_label(sp, &msg);
2394 for sp in field_spans {
2395 err.span_label(sp, "this field is non-zero-sized");
2400 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2401 let adt = tcx.adt_def(def_id);
2402 if !adt.repr.transparent() {
2405 let sp = tcx.sess.source_map().def_span(sp);
2407 if adt.is_enum() && !tcx.features().transparent_enums {
2409 &tcx.sess.parse_sess,
2410 sym::transparent_enums,
2412 "transparent enums are unstable",
2417 if adt.is_union() && !tcx.features().transparent_unions {
2419 &tcx.sess.parse_sess,
2420 sym::transparent_unions,
2422 "transparent unions are unstable",
2427 if adt.variants.len() != 1 {
2428 bad_variant_count(tcx, adt, sp, def_id);
2429 if adt.variants.is_empty() {
2430 // Don't bother checking the fields. No variants (and thus no fields) exist.
2435 // For each field, figure out if it's known to be a ZST and align(1)
2436 let field_infos = adt.all_fields().map(|field| {
2437 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2438 let param_env = tcx.param_env(field.did);
2439 let layout = tcx.layout_of(param_env.and(ty));
2440 // We are currently checking the type this field came from, so it must be local
2441 let span = tcx.hir().span_if_local(field.did).unwrap();
2442 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2443 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2447 let non_zst_fields =
2448 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2449 let non_zst_count = non_zst_fields.clone().count();
2450 if non_zst_count != 1 {
2451 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2453 for (span, zst, align1) in field_infos {
2459 "zero-sized field in transparent {} has alignment larger than 1",
2462 .span_label(span, "has alignment larger than 1")
2468 #[allow(trivial_numeric_casts)]
2469 pub fn check_enum<'tcx>(
2472 vs: &'tcx [hir::Variant<'tcx>],
2475 let def_id = tcx.hir().local_def_id(id);
2476 let def = tcx.adt_def(def_id);
2477 def.destructor(tcx); // force the destructor to be evaluated
2480 let attributes = tcx.get_attrs(def_id);
2481 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2486 "unsupported representation for zero-variant enum"
2488 .span_label(sp, "zero-variant enum")
2493 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2494 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2495 if !tcx.features().repr128 {
2497 &tcx.sess.parse_sess,
2500 "repr with 128-bit type is unstable",
2507 if let Some(ref e) = v.disr_expr {
2508 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2512 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2513 let is_unit = |var: &hir::Variant<'_>| match var.data {
2514 hir::VariantData::Unit(..) => true,
2518 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2519 let has_non_units = vs.iter().any(|var| !is_unit(var));
2520 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2521 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2523 if disr_non_unit || (disr_units && has_non_units) {
2525 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2530 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2531 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2532 // Check for duplicate discriminant values
2533 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2534 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2535 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2536 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2537 let i_span = match variant_i.disr_expr {
2538 Some(ref expr) => tcx.hir().span(expr.hir_id),
2539 None => tcx.hir().span(variant_i_hir_id),
2541 let span = match v.disr_expr {
2542 Some(ref expr) => tcx.hir().span(expr.hir_id),
2549 "discriminant value `{}` already exists",
2552 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2553 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2556 disr_vals.push(discr);
2559 check_representable(tcx, sp, def_id);
2560 check_transparent(tcx, sp, def_id);
2563 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath<'_>) {
2568 "expected unit struct, unit variant or constant, found {} `{}`",
2570 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false))
2575 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2576 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2580 fn item_def_id(&self) -> Option<DefId> {
2584 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2586 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2587 let item_id = tcx.hir().ty_param_owner(hir_id);
2588 let item_def_id = tcx.hir().local_def_id(item_id);
2589 let generics = tcx.generics_of(item_def_id);
2590 let index = generics.param_def_id_to_index[&def_id];
2591 ty::GenericPredicates {
2593 predicates: tcx.arena.alloc_from_iter(self.param_env.caller_bounds.iter().filter_map(
2594 |&predicate| match predicate {
2595 ty::Predicate::Trait(ref data)
2596 if data.skip_binder().self_ty().is_param(index) =>
2598 // HACK(eddyb) should get the original `Span`.
2599 let span = tcx.def_span(def_id);
2600 Some((predicate, span))
2608 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2610 Some(def) => infer::EarlyBoundRegion(span, def.name),
2611 None => infer::MiscVariable(span),
2613 Some(self.next_region_var(v))
2616 fn allow_ty_infer(&self) -> bool {
2620 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2621 if let Some(param) = param {
2622 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2627 self.next_ty_var(TypeVariableOrigin {
2628 kind: TypeVariableOriginKind::TypeInference,
2637 param: Option<&ty::GenericParamDef>,
2639 ) -> &'tcx Const<'tcx> {
2640 if let Some(param) = param {
2641 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2646 self.next_const_var(
2648 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2653 fn projected_ty_from_poly_trait_ref(
2657 item_segment: &hir::PathSegment<'_>,
2658 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2660 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2662 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2666 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
2675 self.tcx().mk_projection(item_def_id, item_substs)
2678 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2679 if ty.has_escaping_bound_vars() {
2680 ty // FIXME: normalization and escaping regions
2682 self.normalize_associated_types_in(span, &ty)
2686 fn set_tainted_by_errors(&self) {
2687 self.infcx.set_tainted_by_errors()
2690 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2691 self.write_ty(hir_id, ty)
2695 /// Controls whether the arguments are tupled. This is used for the call
2698 /// Tupling means that all call-side arguments are packed into a tuple and
2699 /// passed as a single parameter. For example, if tupling is enabled, this
2702 /// fn f(x: (isize, isize))
2704 /// Can be called as:
2711 #[derive(Clone, Eq, PartialEq)]
2712 enum TupleArgumentsFlag {
2717 /// Controls how we perform fallback for unconstrained
2720 /// Do not fallback type variables to opaque types.
2722 /// Perform all possible kinds of fallback, including
2723 /// turning type variables to opaque types.
2727 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2729 inh: &'a Inherited<'a, 'tcx>,
2730 param_env: ty::ParamEnv<'tcx>,
2731 body_id: hir::HirId,
2732 ) -> FnCtxt<'a, 'tcx> {
2736 err_count_on_creation: inh.tcx.sess.err_count(),
2738 ret_coercion_span: RefCell::new(None),
2740 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
2741 diverges: Cell::new(Diverges::Maybe),
2742 has_errors: Cell::new(false),
2743 enclosing_breakables: RefCell::new(EnclosingBreakables {
2745 by_id: Default::default(),
2751 pub fn sess(&self) -> &Session {
2755 pub fn errors_reported_since_creation(&self) -> bool {
2756 self.tcx.sess.err_count() > self.err_count_on_creation
2759 /// Produces warning on the given node, if the current point in the
2760 /// function is unreachable, and there hasn't been another warning.
2761 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2762 // FIXME: Combine these two 'if' expressions into one once
2763 // let chains are implemented
2764 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2765 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2766 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2767 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2768 if !span.is_desugaring(DesugaringKind::CondTemporary)
2769 && !span.is_desugaring(DesugaringKind::Async)
2770 && !orig_span.is_desugaring(DesugaringKind::Await)
2772 self.diverges.set(Diverges::WarnedAlways);
2774 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2776 let msg = format!("unreachable {}", kind);
2778 .struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2779 .span_label(span, &msg)
2782 custom_note.unwrap_or("any code following this expression is unreachable"),
2789 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
2790 ObligationCause::new(span, self.body_id, code)
2793 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2794 self.cause(span, ObligationCauseCode::MiscObligation)
2797 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2798 /// version (resolve_vars_if_possible), this version will
2799 /// also select obligations if it seems useful, in an effort
2800 /// to get more type information.
2801 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2802 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2804 // No Infer()? Nothing needs doing.
2805 if !ty.has_infer_types() && !ty.has_infer_consts() {
2806 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2810 // If `ty` is a type variable, see whether we already know what it is.
2811 ty = self.resolve_vars_if_possible(&ty);
2812 if !ty.has_infer_types() && !ty.has_infer_consts() {
2813 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2817 // If not, try resolving pending obligations as much as
2818 // possible. This can help substantially when there are
2819 // indirect dependencies that don't seem worth tracking
2821 self.select_obligations_where_possible(false, |_| {});
2822 ty = self.resolve_vars_if_possible(&ty);
2824 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2828 fn record_deferred_call_resolution(
2830 closure_def_id: DefId,
2831 r: DeferredCallResolution<'tcx>,
2833 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2834 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2837 fn remove_deferred_call_resolutions(
2839 closure_def_id: DefId,
2840 ) -> Vec<DeferredCallResolution<'tcx>> {
2841 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2842 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2845 pub fn tag(&self) -> String {
2846 format!("{:p}", self)
2849 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2850 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
2851 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
2856 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2858 "write_ty({:?}, {:?}) in fcx {}",
2860 self.resolve_vars_if_possible(&ty),
2863 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2865 if ty.references_error() {
2866 self.has_errors.set(true);
2867 self.set_tainted_by_errors();
2871 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2872 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2875 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2876 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2879 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
2880 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2881 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2882 self.write_substs(hir_id, method.substs);
2884 // When the method is confirmed, the `method.substs` includes
2885 // parameters from not just the method, but also the impl of
2886 // the method -- in particular, the `Self` type will be fully
2887 // resolved. However, those are not something that the "user
2888 // specified" -- i.e., those types come from the inferred type
2889 // of the receiver, not something the user wrote. So when we
2890 // create the user-substs, we want to replace those earlier
2891 // types with just the types that the user actually wrote --
2892 // that is, those that appear on the *method itself*.
2894 // As an example, if the user wrote something like
2895 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2896 // type of `foo` (possibly adjusted), but we don't want to
2897 // include that. We want just the `[_, u32]` part.
2898 if !method.substs.is_noop() {
2899 let method_generics = self.tcx.generics_of(method.def_id);
2900 if !method_generics.params.is_empty() {
2901 let user_type_annotation = self.infcx.probe(|_| {
2902 let user_substs = UserSubsts {
2903 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2904 let i = param.index as usize;
2905 if i < method_generics.parent_count {
2906 self.infcx.var_for_def(DUMMY_SP, param)
2911 user_self_ty: None, // not relevant here
2914 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2920 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2921 self.write_user_type_annotation(hir_id, user_type_annotation);
2926 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2927 if !substs.is_noop() {
2928 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
2930 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2934 /// Given the substs that we just converted from the HIR, try to
2935 /// canonicalize them and store them as user-given substitutions
2936 /// (i.e., substitutions that must be respected by the NLL check).
2938 /// This should be invoked **before any unifications have
2939 /// occurred**, so that annotations like `Vec<_>` are preserved
2941 pub fn write_user_type_annotation_from_substs(
2945 substs: SubstsRef<'tcx>,
2946 user_self_ty: Option<UserSelfTy<'tcx>>,
2949 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2950 user_self_ty={:?} in fcx {}",
2958 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2959 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2961 UserSubsts { substs, user_self_ty },
2963 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2964 self.write_user_type_annotation(hir_id, canonicalized);
2968 pub fn write_user_type_annotation(
2971 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2974 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2976 canonical_user_type_annotation,
2980 if !canonical_user_type_annotation.is_identity() {
2983 .user_provided_types_mut()
2984 .insert(hir_id, canonical_user_type_annotation);
2986 debug!("write_user_type_annotation: skipping identity substs");
2990 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
2991 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2997 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2998 Entry::Vacant(entry) => {
3001 Entry::Occupied(mut entry) => {
3002 debug!(" - composing on top of {:?}", entry.get());
3003 match (&entry.get()[..], &adj[..]) {
3004 // Applying any adjustment on top of a NeverToAny
3005 // is a valid NeverToAny adjustment, because it can't
3007 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3009 Adjustment { kind: Adjust::Deref(_), .. },
3010 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3012 Adjustment { kind: Adjust::Deref(_), .. },
3013 .. // Any following adjustments are allowed.
3015 // A reborrow has no effect before a dereference.
3017 // FIXME: currently we never try to compose autoderefs
3018 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3020 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3021 expr, entry.get(), adj)
3023 *entry.get_mut() = adj;
3028 /// Basically whenever we are converting from a type scheme into
3029 /// the fn body space, we always want to normalize associated
3030 /// types as well. This function combines the two.
3031 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3033 T: TypeFoldable<'tcx>,
3035 let value = value.subst(self.tcx, substs);
3036 let result = self.normalize_associated_types_in(span, &value);
3037 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3041 /// As `instantiate_type_scheme`, but for the bounds found in a
3042 /// generic type scheme.
3043 fn instantiate_bounds(
3047 substs: SubstsRef<'tcx>,
3048 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3049 let bounds = self.tcx.predicates_of(def_id);
3050 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3051 let result = bounds.instantiate(self.tcx, substs);
3052 let result = self.normalize_associated_types_in(span, &result);
3054 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3055 bounds, substs, result, spans,
3060 /// Replaces the opaque types from the given value with type variables,
3061 /// and records the `OpaqueTypeMap` for later use during writeback. See
3062 /// `InferCtxt::instantiate_opaque_types` for more details.
3063 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3065 parent_id: hir::HirId,
3069 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3071 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3072 parent_def_id, value
3075 let (value, opaque_type_map) =
3076 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3084 let mut opaque_types = self.opaque_types.borrow_mut();
3085 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3086 for (ty, decl) in opaque_type_map {
3087 let _ = opaque_types.insert(ty, decl);
3088 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3094 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3096 T: TypeFoldable<'tcx>,
3098 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3101 fn normalize_associated_types_in_as_infer_ok<T>(
3105 ) -> InferOk<'tcx, T>
3107 T: TypeFoldable<'tcx>,
3109 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3112 pub fn require_type_meets(
3116 code: traits::ObligationCauseCode<'tcx>,
3119 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3122 pub fn require_type_is_sized(
3126 code: traits::ObligationCauseCode<'tcx>,
3128 if !ty.references_error() {
3129 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3130 self.require_type_meets(ty, span, code, lang_item);
3134 pub fn require_type_is_sized_deferred(
3138 code: traits::ObligationCauseCode<'tcx>,
3140 if !ty.references_error() {
3141 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3145 pub fn register_bound(
3149 cause: traits::ObligationCause<'tcx>,
3151 if !ty.references_error() {
3152 self.fulfillment_cx.borrow_mut().register_bound(
3162 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3163 let t = AstConv::ast_ty_to_ty(self, ast_t);
3164 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3168 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3169 let ty = self.to_ty(ast_ty);
3170 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3172 if Self::can_contain_user_lifetime_bounds(ty) {
3173 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3174 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3175 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3181 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3182 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3183 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3186 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3187 AstConv::ast_const_to_const(self, ast_c, ty)
3190 // If the type given by the user has free regions, save it for later, since
3191 // NLL would like to enforce those. Also pass in types that involve
3192 // projections, since those can resolve to `'static` bounds (modulo #54940,
3193 // which hopefully will be fixed by the time you see this comment, dear
3194 // reader, although I have my doubts). Also pass in types with inference
3195 // types, because they may be repeated. Other sorts of things are already
3196 // sufficiently enforced with erased regions. =)
3197 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3199 T: TypeFoldable<'tcx>,
3201 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3204 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3205 match self.tables.borrow().node_types().get(id) {
3207 None if self.is_tainted_by_errors() => self.tcx.types.err,
3210 "no type for node {}: {} in fcx {}",
3212 self.tcx.hir().node_to_string(id),
3219 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3220 /// outlive the region `r`.
3221 pub fn register_wf_obligation(
3225 code: traits::ObligationCauseCode<'tcx>,
3227 // WF obligations never themselves fail, so no real need to give a detailed cause:
3228 let cause = traits::ObligationCause::new(span, self.body_id, code);
3229 self.register_predicate(traits::Obligation::new(
3232 ty::Predicate::WellFormed(ty),
3236 /// Registers obligations that all types appearing in `substs` are well-formed.
3237 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3238 for ty in substs.types() {
3239 if !ty.references_error() {
3240 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3245 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3246 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3247 /// trait/region obligations.
3249 /// For example, if there is a function:
3252 /// fn foo<'a,T:'a>(...)
3255 /// and a reference:
3261 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3262 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3263 pub fn add_obligations_for_parameters(
3265 cause: traits::ObligationCause<'tcx>,
3266 predicates: &ty::InstantiatedPredicates<'tcx>,
3268 assert!(!predicates.has_escaping_bound_vars());
3270 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3272 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3273 self.register_predicate(obligation);
3277 // FIXME(arielb1): use this instead of field.ty everywhere
3278 // Only for fields! Returns <none> for methods>
3279 // Indifferent to privacy flags
3283 field: &'tcx ty::FieldDef,
3284 substs: SubstsRef<'tcx>,
3286 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3289 fn check_casts(&self) {
3290 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3291 for cast in deferred_cast_checks.drain(..) {
3296 fn resolve_generator_interiors(&self, def_id: DefId) {
3297 let mut generators = self.deferred_generator_interiors.borrow_mut();
3298 for (body_id, interior, kind) in generators.drain(..) {
3299 self.select_obligations_where_possible(false, |_| {});
3300 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3304 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3306 // - Unconstrained ints are replaced with `i32`.
3308 // - Unconstrained floats are replaced with with `f64`.
3310 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3311 // is enabled. Otherwise, they are replaced with `()`.
3313 // Fallback becomes very dubious if we have encountered type-checking errors.
3314 // In that case, fallback to Error.
3315 // The return value indicates whether fallback has occurred.
3316 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3317 use rustc::ty::error::UnconstrainedNumeric::Neither;
3318 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3320 assert!(ty.is_ty_infer());
3321 let fallback = match self.type_is_unconstrained_numeric(ty) {
3322 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3323 UnconstrainedInt => self.tcx.types.i32,
3324 UnconstrainedFloat => self.tcx.types.f64,
3325 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3327 // This type variable was created from the instantiation of an opaque
3328 // type. The fact that we're attempting to perform fallback for it
3329 // means that the function neither constrained it to a concrete
3330 // type, nor to the opaque type itself.
3332 // For example, in this code:
3335 // type MyType = impl Copy;
3336 // fn defining_use() -> MyType { true }
3337 // fn other_use() -> MyType { defining_use() }
3340 // `defining_use` will constrain the instantiated inference
3341 // variable to `bool`, while `other_use` will constrain
3342 // the instantiated inference variable to `MyType`.
3344 // When we process opaque types during writeback, we
3345 // will handle cases like `other_use`, and not count
3346 // them as defining usages
3348 // However, we also need to handle cases like this:
3351 // pub type Foo = impl Copy;
3352 // fn produce() -> Option<Foo> {
3357 // In the above snippet, the inference varaible created by
3358 // instantiating `Option<Foo>` will be completely unconstrained.
3359 // We treat this as a non-defining use by making the inference
3360 // variable fall back to the opaque type itself.
3361 if let FallbackMode::All = mode {
3362 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3364 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3376 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3377 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3381 fn select_all_obligations_or_error(&self) {
3382 debug!("select_all_obligations_or_error");
3383 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3384 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3388 /// Select as many obligations as we can at present.
3389 fn select_obligations_where_possible(
3391 fallback_has_occurred: bool,
3392 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3394 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3395 if let Err(mut errors) = result {
3396 mutate_fullfillment_errors(&mut errors);
3397 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3401 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3402 /// returns a type of `&T`, but the actual type we assign to the
3403 /// *expression* is `T`. So this function just peels off the return
3404 /// type by one layer to yield `T`.
3405 fn make_overloaded_place_return_type(
3407 method: MethodCallee<'tcx>,
3408 ) -> ty::TypeAndMut<'tcx> {
3409 // extract method return type, which will be &T;
3410 let ret_ty = method.sig.output();
3412 // method returns &T, but the type as visible to user is T, so deref
3413 ret_ty.builtin_deref(true).unwrap()
3418 expr: &hir::Expr<'_>,
3419 base_expr: &'tcx hir::Expr<'tcx>,
3423 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3424 // FIXME(#18741) -- this is almost but not quite the same as the
3425 // autoderef that normal method probing does. They could likely be
3428 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3429 let mut result = None;
3430 while result.is_none() && autoderef.next().is_some() {
3431 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3433 autoderef.finalize(self);
3437 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3438 /// (and otherwise adjust) `base_expr`, looking for a type which either
3439 /// supports builtin indexing or overloaded indexing.
3440 /// This loop implements one step in that search; the autoderef loop
3441 /// is implemented by `lookup_indexing`.
3444 expr: &hir::Expr<'_>,
3445 base_expr: &hir::Expr<'_>,
3446 autoderef: &Autoderef<'a, 'tcx>,
3449 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3450 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3452 "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3454 expr, base_expr, adjusted_ty, index_ty
3457 for &unsize in &[false, true] {
3458 let mut self_ty = adjusted_ty;
3460 // We only unsize arrays here.
3461 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3462 self_ty = self.tcx.mk_slice(element_ty);
3468 // If some lookup succeeds, write callee into table and extract index/element
3469 // type from the method signature.
3470 // If some lookup succeeded, install method in table
3471 let input_ty = self.next_ty_var(TypeVariableOrigin {
3472 kind: TypeVariableOriginKind::AutoDeref,
3473 span: base_expr.span,
3475 let method = self.try_overloaded_place_op(
3483 let result = method.map(|ok| {
3484 debug!("try_index_step: success, using overloaded indexing");
3485 let method = self.register_infer_ok_obligations(ok);
3487 let mut adjustments = autoderef.adjust_steps(self, needs);
3488 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3489 let mutbl = match r_mutbl {
3490 hir::Mutability::Not => AutoBorrowMutability::Not,
3491 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3492 // Indexing can be desugared to a method call,
3493 // so maybe we could use two-phase here.
3494 // See the documentation of AllowTwoPhase for why that's
3495 // not the case today.
3496 allow_two_phase_borrow: AllowTwoPhase::No,
3499 adjustments.push(Adjustment {
3500 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3503 .mk_ref(region, ty::TypeAndMut { mutbl: r_mutbl, ty: adjusted_ty }),
3507 adjustments.push(Adjustment {
3508 kind: Adjust::Pointer(PointerCast::Unsize),
3509 target: method.sig.inputs()[0],
3512 self.apply_adjustments(base_expr, adjustments);
3514 self.write_method_call(expr.hir_id, method);
3515 (input_ty, self.make_overloaded_place_return_type(method).ty)
3517 if result.is_some() {
3525 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3526 let (tr, name) = match (op, is_mut) {
3527 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3528 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3529 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3530 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3532 (tr, ast::Ident::with_dummy_span(name))
3535 fn try_overloaded_place_op(
3539 arg_tys: &[Ty<'tcx>],
3542 ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
3543 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})", span, base_ty, needs, op);
3545 // Try Mut first, if needed.
3546 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3547 let method = match (needs, mut_tr) {
3548 (Needs::MutPlace, Some(trait_did)) => {
3549 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3554 // Otherwise, fall back to the immutable version.
3555 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3556 let method = match (method, imm_tr) {
3557 (None, Some(trait_did)) => {
3558 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3560 (method, _) => method,
3566 fn check_method_argument_types(
3569 expr: &'tcx hir::Expr<'tcx>,
3570 method: Result<MethodCallee<'tcx>, ()>,
3571 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3572 tuple_arguments: TupleArgumentsFlag,
3573 expected: Expectation<'tcx>,
3575 let has_error = match method {
3576 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3580 let err_inputs = self.err_args(args_no_rcvr.len());
3582 let err_inputs = match tuple_arguments {
3583 DontTupleArguments => err_inputs,
3584 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3587 self.check_argument_types(
3597 return self.tcx.types.err;
3600 let method = method.unwrap();
3601 // HACK(eddyb) ignore self in the definition (see above).
3602 let expected_arg_tys = self.expected_inputs_for_expected_output(
3605 method.sig.output(),
3606 &method.sig.inputs()[1..],
3608 self.check_argument_types(
3611 &method.sig.inputs()[1..],
3612 &expected_arg_tys[..],
3614 method.sig.c_variadic,
3616 self.tcx.hir().span_if_local(method.def_id),
3621 fn self_type_matches_expected_vid(
3623 trait_ref: ty::PolyTraitRef<'tcx>,
3624 expected_vid: ty::TyVid,
3626 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3628 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3629 trait_ref, self_ty, expected_vid
3631 match self_ty.kind {
3632 ty::Infer(ty::TyVar(found_vid)) => {
3633 // FIXME: consider using `sub_root_var` here so we
3634 // can see through subtyping.
3635 let found_vid = self.root_var(found_vid);
3636 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3637 expected_vid == found_vid
3643 fn obligations_for_self_ty<'b>(
3646 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3649 // FIXME: consider using `sub_root_var` here so we
3650 // can see through subtyping.
3651 let ty_var_root = self.root_var(self_ty);
3653 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3656 self.fulfillment_cx.borrow().pending_obligations()
3661 .pending_obligations()
3663 .filter_map(move |obligation| match obligation.predicate {
3664 ty::Predicate::Projection(ref data) => {
3665 Some((data.to_poly_trait_ref(self.tcx), obligation))
3667 ty::Predicate::Trait(ref data) => Some((data.to_poly_trait_ref(), obligation)),
3668 ty::Predicate::Subtype(..) => None,
3669 ty::Predicate::RegionOutlives(..) => None,
3670 ty::Predicate::TypeOutlives(..) => None,
3671 ty::Predicate::WellFormed(..) => None,
3672 ty::Predicate::ObjectSafe(..) => None,
3673 ty::Predicate::ConstEvaluatable(..) => None,
3674 // N.B., this predicate is created by breaking down a
3675 // `ClosureType: FnFoo()` predicate, where
3676 // `ClosureType` represents some `Closure`. It can't
3677 // possibly be referring to the current closure,
3678 // because we haven't produced the `Closure` for
3679 // this closure yet; this is exactly why the other
3680 // code is looking for a self type of a unresolved
3681 // inference variable.
3682 ty::Predicate::ClosureKind(..) => None,
3684 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3687 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3688 self.obligations_for_self_ty(self_ty)
3689 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3692 /// Generic function that factors out common logic from function calls,
3693 /// method calls and overloaded operators.
3694 fn check_argument_types(
3697 expr: &'tcx hir::Expr<'tcx>,
3698 fn_inputs: &[Ty<'tcx>],
3699 expected_arg_tys: &[Ty<'tcx>],
3700 args: &'tcx [hir::Expr<'tcx>],
3702 tuple_arguments: TupleArgumentsFlag,
3703 def_span: Option<Span>,
3706 // Grab the argument types, supplying fresh type variables
3707 // if the wrong number of arguments were supplied
3708 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3710 // All the input types from the fn signature must outlive the call
3711 // so as to validate implied bounds.
3712 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3713 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3716 let expected_arg_count = fn_inputs.len();
3718 let param_count_error = |expected_count: usize,
3723 let mut err = tcx.sess.struct_span_err_with_code(
3726 "this function takes {}{} but {} {} supplied",
3727 if c_variadic { "at least " } else { "" },
3728 potentially_plural_count(expected_count, "parameter"),
3729 potentially_plural_count(arg_count, "parameter"),
3730 if arg_count == 1 { "was" } else { "were" }
3732 DiagnosticId::Error(error_code.to_owned()),
3735 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3736 err.span_label(def_s, "defined here");
3739 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3740 // remove closing `)` from the span
3741 let sugg_span = sugg_span.shrink_to_lo();
3742 err.span_suggestion(
3744 "expected the unit value `()`; create it with empty parentheses",
3746 Applicability::MachineApplicable,
3753 if c_variadic { "at least " } else { "" },
3754 potentially_plural_count(expected_count, "parameter")
3761 let mut expected_arg_tys = expected_arg_tys.to_vec();
3763 let formal_tys = if tuple_arguments == TupleArguments {
3764 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3765 match tuple_type.kind {
3766 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3767 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3768 expected_arg_tys = vec![];
3769 self.err_args(args.len())
3771 ty::Tuple(arg_types) => {
3772 expected_arg_tys = match expected_arg_tys.get(0) {
3773 Some(&ty) => match ty.kind {
3774 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3779 arg_types.iter().map(|k| k.expect_ty()).collect()
3786 "cannot use call notation; the first type parameter \
3787 for the function trait is neither a tuple nor unit"
3790 expected_arg_tys = vec![];
3791 self.err_args(args.len())
3794 } else if expected_arg_count == supplied_arg_count {
3796 } else if c_variadic {
3797 if supplied_arg_count >= expected_arg_count {
3800 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3801 expected_arg_tys = vec![];
3802 self.err_args(supplied_arg_count)
3805 // is the missing argument of type `()`?
3806 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3807 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3808 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3809 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3813 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3815 expected_arg_tys = vec![];
3816 self.err_args(supplied_arg_count)
3820 "check_argument_types: formal_tys={:?}",
3821 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
3824 // If there is no expectation, expect formal_tys.
3825 let expected_arg_tys =
3826 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
3828 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3830 // Check the arguments.
3831 // We do this in a pretty awful way: first we type-check any arguments
3832 // that are not closures, then we type-check the closures. This is so
3833 // that we have more information about the types of arguments when we
3834 // type-check the functions. This isn't really the right way to do this.
3835 for &check_closures in &[false, true] {
3836 debug!("check_closures={}", check_closures);
3838 // More awful hacks: before we check argument types, try to do
3839 // an "opportunistic" vtable resolution of any trait bounds on
3840 // the call. This helps coercions.
3842 self.select_obligations_where_possible(false, |errors| {
3843 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3844 self.point_at_arg_instead_of_call_if_possible(
3846 &final_arg_types[..],
3853 // For C-variadic functions, we don't have a declared type for all of
3854 // the arguments hence we only do our usual type checking with
3855 // the arguments who's types we do know.
3856 let t = if c_variadic {
3858 } else if tuple_arguments == TupleArguments {
3863 for (i, arg) in args.iter().take(t).enumerate() {
3864 // Warn only for the first loop (the "no closures" one).
3865 // Closure arguments themselves can't be diverging, but
3866 // a previous argument can, e.g., `foo(panic!(), || {})`.
3867 if !check_closures {
3868 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3871 let is_closure = match arg.kind {
3872 ExprKind::Closure(..) => true,
3876 if is_closure != check_closures {
3880 debug!("checking the argument");
3881 let formal_ty = formal_tys[i];
3883 // The special-cased logic below has three functions:
3884 // 1. Provide as good of an expected type as possible.
3885 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3887 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3889 // 2. Coerce to the most detailed type that could be coerced
3890 // to, which is `expected_ty` if `rvalue_hint` returns an
3891 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3892 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3893 // We're processing function arguments so we definitely want to use
3894 // two-phase borrows.
3895 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3896 final_arg_types.push((i, checked_ty, coerce_ty));
3898 // 3. Relate the expected type and the formal one,
3899 // if the expected type was used for the coercion.
3900 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3904 // We also need to make sure we at least write the ty of the other
3905 // arguments which we skipped above.
3907 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3908 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
3909 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3912 for arg in args.iter().skip(expected_arg_count) {
3913 let arg_ty = self.check_expr(&arg);
3915 // There are a few types which get autopromoted when passed via varargs
3916 // in C but we just error out instead and require explicit casts.
3917 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3919 ty::Float(ast::FloatTy::F32) => {
3920 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3922 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3923 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3925 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3926 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3929 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3930 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3931 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3939 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3940 vec![self.tcx.types.err; len]
3943 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
3944 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
3945 /// reference a type argument. The reason to walk also the checked type is that the coerced type
3946 /// can be not easily comparable with predicate type (because of coercion). If the types match
3947 /// for either checked or coerced type, and there's only *one* argument that does, we point at
3948 /// the corresponding argument's expression span instead of the `fn` call path span.
3949 fn point_at_arg_instead_of_call_if_possible(
3951 errors: &mut Vec<traits::FulfillmentError<'_>>,
3952 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
3954 args: &'tcx [hir::Expr<'tcx>],
3956 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3957 // the `?` operator.
3958 if call_sp.desugaring_kind().is_some() {
3962 for error in errors {
3963 // Only if the cause is somewhere inside the expression we want try to point at arg.
3964 // Otherwise, it means that the cause is somewhere else and we should not change
3965 // anything because we can break the correct span.
3966 if !call_sp.contains(error.obligation.cause.span) {
3970 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3971 // Collect the argument position for all arguments that could have caused this
3972 // `FulfillmentError`.
3973 let mut referenced_in = final_arg_types
3975 .map(|(i, checked_ty, _)| (i, checked_ty))
3976 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
3977 .flat_map(|(i, ty)| {
3978 let ty = self.resolve_vars_if_possible(ty);
3979 // We walk the argument type because the argument's type could have
3980 // been `Option<T>`, but the `FulfillmentError` references `T`.
3982 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3985 .collect::<Vec<_>>();
3987 // Both checked and coerced types could have matched, thus we need to remove
3989 referenced_in.dedup();
3991 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
3992 // We make sure that only *one* argument matches the obligation failure
3993 // and we assign the obligation's span to its expression's.
3994 error.obligation.cause.span = args[ref_in].span;
3995 error.points_at_arg_span = true;
4001 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4002 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4003 /// were caused by them. If they were, we point at the corresponding type argument's span
4004 /// instead of the `fn` call path span.
4005 fn point_at_type_arg_instead_of_call_if_possible(
4007 errors: &mut Vec<traits::FulfillmentError<'_>>,
4008 call_expr: &'tcx hir::Expr<'tcx>,
4010 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4011 if let hir::ExprKind::Path(qpath) = &path.kind {
4012 if let hir::QPath::Resolved(_, path) = &qpath {
4013 for error in errors {
4014 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
4015 // If any of the type arguments in this path segment caused the
4016 // `FullfillmentError`, point at its span (#61860).
4020 .filter_map(|seg| seg.args.as_ref())
4021 .flat_map(|a| a.args.iter())
4023 if let hir::GenericArg::Type(hir_ty) = &arg {
4024 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4027 // Avoid ICE with associated types. As this is best
4028 // effort only, it's ok to ignore the case. It
4029 // would trigger in `is_send::<T::AssocType>();`
4030 // from `typeck-default-trait-impl-assoc-type.rs`.
4032 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4033 let ty = self.resolve_vars_if_possible(&ty);
4034 if ty == predicate.skip_binder().self_ty() {
4035 error.obligation.cause.span = hir_ty.span;
4047 // AST fragment checking
4048 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4052 ast::LitKind::Str(..) => tcx.mk_static_str(),
4053 ast::LitKind::ByteStr(ref v) => {
4054 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4056 ast::LitKind::Byte(_) => tcx.types.u8,
4057 ast::LitKind::Char(_) => tcx.types.char,
4058 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4059 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4060 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4061 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4062 ty::Int(_) | ty::Uint(_) => Some(ty),
4063 ty::Char => Some(tcx.types.u8),
4064 ty::RawPtr(..) => Some(tcx.types.usize),
4065 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4068 opt_ty.unwrap_or_else(|| self.next_int_var())
4070 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4071 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4072 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4073 ty::Float(_) => Some(ty),
4076 opt_ty.unwrap_or_else(|| self.next_float_var())
4078 ast::LitKind::Bool(_) => tcx.types.bool,
4079 ast::LitKind::Err(_) => tcx.types.err,
4083 // Determine the `Self` type, using fresh variables for all variables
4084 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4085 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4087 pub fn impl_self_ty(
4089 span: Span, // (potential) receiver for this impl
4091 ) -> TypeAndSubsts<'tcx> {
4092 let ity = self.tcx.type_of(did);
4093 debug!("impl_self_ty: ity={:?}", ity);
4095 let substs = self.fresh_substs_for_item(span, did);
4096 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4098 TypeAndSubsts { substs: substs, ty: substd_ty }
4101 /// Unifies the output type with the expected type early, for more coercions
4102 /// and forward type information on the input expressions.
4103 fn expected_inputs_for_expected_output(
4106 expected_ret: Expectation<'tcx>,
4107 formal_ret: Ty<'tcx>,
4108 formal_args: &[Ty<'tcx>],
4109 ) -> Vec<Ty<'tcx>> {
4110 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4111 let ret_ty = match expected_ret.only_has_type(self) {
4113 None => return Vec::new(),
4115 let expect_args = self
4116 .fudge_inference_if_ok(|| {
4117 // Attempt to apply a subtyping relationship between the formal
4118 // return type (likely containing type variables if the function
4119 // is polymorphic) and the expected return type.
4120 // No argument expectations are produced if unification fails.
4121 let origin = self.misc(call_span);
4122 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4124 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4125 // to identity so the resulting type is not constrained.
4128 // Process any obligations locally as much as
4129 // we can. We don't care if some things turn
4130 // out unconstrained or ambiguous, as we're
4131 // just trying to get hints here.
4132 self.save_and_restore_in_snapshot_flag(|_| {
4133 let mut fulfill = TraitEngine::new(self.tcx);
4134 for obligation in ok.obligations {
4135 fulfill.register_predicate_obligation(self, obligation);
4137 fulfill.select_where_possible(self)
4141 Err(_) => return Err(()),
4144 // Record all the argument types, with the substitutions
4145 // produced from the above subtyping unification.
4146 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4148 .unwrap_or_default();
4150 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4151 formal_args, formal_ret, expect_args, expected_ret
4156 pub fn check_struct_path(
4160 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4161 let path_span = match *qpath {
4162 QPath::Resolved(_, ref path) => path.span,
4163 QPath::TypeRelative(ref qself, _) => qself.span,
4165 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4166 let variant = match def {
4168 self.set_tainted_by_errors();
4171 Res::Def(DefKind::Variant, _) => match ty.kind {
4172 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4173 _ => bug!("unexpected type: {:?}", ty),
4175 Res::Def(DefKind::Struct, _)
4176 | Res::Def(DefKind::Union, _)
4177 | Res::Def(DefKind::TyAlias, _)
4178 | Res::Def(DefKind::AssocTy, _)
4179 | Res::SelfTy(..) => match ty.kind {
4180 ty::Adt(adt, substs) if !adt.is_enum() => {
4181 Some((adt.non_enum_variant(), adt.did, substs))
4185 _ => bug!("unexpected definition: {:?}", def),
4188 if let Some((variant, did, substs)) = variant {
4189 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4190 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4192 // Check bounds on type arguments used in the path.
4193 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4195 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4196 self.add_obligations_for_parameters(cause, &bounds);
4204 "expected struct, variant or union type, found {}",
4205 ty.sort_string(self.tcx)
4207 .span_label(path_span, "not a struct")
4213 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4214 // The newly resolved definition is written into `type_dependent_defs`.
4215 fn finish_resolving_struct_path(
4220 ) -> (Res, Ty<'tcx>) {
4222 QPath::Resolved(ref maybe_qself, ref path) => {
4223 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4224 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4227 QPath::TypeRelative(ref qself, ref segment) => {
4228 let ty = self.to_ty(qself);
4230 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4236 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4237 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4238 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4240 // Write back the new resolution.
4241 self.write_resolution(hir_id, result);
4243 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4248 /// Resolves an associated value path into a base type and associated constant, or method
4249 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4250 pub fn resolve_ty_and_res_ufcs<'b>(
4252 qpath: &'b QPath<'b>,
4255 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4256 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4257 let (ty, qself, item_segment) = match *qpath {
4258 QPath::Resolved(ref opt_qself, ref path) => {
4261 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4265 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4267 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4268 // Return directly on cache hit. This is useful to avoid doubly reporting
4269 // errors with default match binding modes. See #44614.
4271 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4272 return (def, Some(ty), slice::from_ref(&**item_segment));
4274 let item_name = item_segment.ident;
4275 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4276 let result = match error {
4277 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4278 _ => Err(ErrorReported),
4280 if item_name.name != kw::Invalid {
4281 self.report_method_error(
4285 SelfSource::QPath(qself),
4289 .map(|mut e| e.emit());
4294 // Write back the new resolution.
4295 self.write_resolution(hir_id, result);
4297 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4299 slice::from_ref(&**item_segment),
4303 pub fn check_decl_initializer(
4305 local: &'tcx hir::Local<'tcx>,
4306 init: &'tcx hir::Expr<'tcx>,
4308 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4309 // for #42640 (default match binding modes).
4312 let ref_bindings = local.pat.contains_explicit_ref_binding();
4314 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4315 if let Some(m) = ref_bindings {
4316 // Somewhat subtle: if we have a `ref` binding in the pattern,
4317 // we want to avoid introducing coercions for the RHS. This is
4318 // both because it helps preserve sanity and, in the case of
4319 // ref mut, for soundness (issue #23116). In particular, in
4320 // the latter case, we need to be clear that the type of the
4321 // referent for the reference that results is *equal to* the
4322 // type of the place it is referencing, and not some
4323 // supertype thereof.
4324 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4325 self.demand_eqtype(init.span, local_ty, init_ty);
4328 self.check_expr_coercable_to_type(init, local_ty)
4332 /// Type check a `let` statement.
4333 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4334 // Determine and write the type which we'll check the pattern against.
4335 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4336 self.write_ty(local.hir_id, ty);
4338 // Type check the initializer.
4339 if let Some(ref init) = local.init {
4340 let init_ty = self.check_decl_initializer(local, &init);
4341 self.overwrite_local_ty_if_err(local, ty, init_ty);
4344 // Does the expected pattern type originate from an expression and what is the span?
4345 let (origin_expr, ty_span) = match (local.ty, local.init) {
4346 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4347 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4348 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4351 // Type check the pattern. Override if necessary to avoid knock-on errors.
4352 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4353 let pat_ty = self.node_ty(local.pat.hir_id);
4354 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4357 fn overwrite_local_ty_if_err(
4359 local: &'tcx hir::Local<'tcx>,
4363 if ty.references_error() {
4364 // Override the types everywhere with `types.err` to avoid knock on errors.
4365 self.write_ty(local.hir_id, ty);
4366 self.write_ty(local.pat.hir_id, ty);
4367 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4368 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4369 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4373 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4374 err.span_suggestion_short(
4375 span.shrink_to_hi(),
4376 "consider using a semicolon here",
4378 Applicability::MachineApplicable,
4382 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4383 // Don't do all the complex logic below for `DeclItem`.
4385 hir::StmtKind::Item(..) => return,
4386 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4389 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4391 // Hide the outer diverging and `has_errors` flags.
4392 let old_diverges = self.diverges.get();
4393 let old_has_errors = self.has_errors.get();
4394 self.diverges.set(Diverges::Maybe);
4395 self.has_errors.set(false);
4398 hir::StmtKind::Local(ref l) => {
4399 self.check_decl_local(&l);
4402 hir::StmtKind::Item(_) => {}
4403 hir::StmtKind::Expr(ref expr) => {
4404 // Check with expected type of `()`.
4406 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4407 self.suggest_semicolon_at_end(expr.span, err);
4410 hir::StmtKind::Semi(ref expr) => {
4411 self.check_expr(&expr);
4415 // Combine the diverging and `has_error` flags.
4416 self.diverges.set(self.diverges.get() | old_diverges);
4417 self.has_errors.set(self.has_errors.get() | old_has_errors);
4420 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4421 let unit = self.tcx.mk_unit();
4422 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4424 // if the block produces a `!` value, that can always be
4425 // (effectively) coerced to unit.
4427 self.demand_suptype(blk.span, unit, ty);
4431 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4432 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4433 /// when given code like the following:
4435 /// if false { return 0i32; } else { 1u32 }
4436 /// // ^^^^ point at this instead of the whole `if` expression
4438 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4439 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4440 let arm_spans: Vec<Span> = arms
4443 self.in_progress_tables
4444 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4445 .and_then(|arm_ty| {
4446 if arm_ty.is_never() {
4449 Some(match &arm.body.kind {
4450 // Point at the tail expression when possible.
4451 hir::ExprKind::Block(block, _) => {
4452 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4460 if arm_spans.len() == 1 {
4461 return arm_spans[0];
4467 fn check_block_with_expected(
4469 blk: &'tcx hir::Block<'tcx>,
4470 expected: Expectation<'tcx>,
4473 let mut fcx_ps = self.ps.borrow_mut();
4474 let unsafety_state = fcx_ps.recurse(blk);
4475 replace(&mut *fcx_ps, unsafety_state)
4478 // In some cases, blocks have just one exit, but other blocks
4479 // can be targeted by multiple breaks. This can happen both
4480 // with labeled blocks as well as when we desugar
4481 // a `try { ... }` expression.
4485 // 'a: { if true { break 'a Err(()); } Ok(()) }
4487 // Here we would wind up with two coercions, one from
4488 // `Err(())` and the other from the tail expression
4489 // `Ok(())`. If the tail expression is omitted, that's a
4490 // "forced unit" -- unless the block diverges, in which
4491 // case we can ignore the tail expression (e.g., `'a: {
4492 // break 'a 22; }` would not force the type of the block
4494 let tail_expr = blk.expr.as_ref();
4495 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4496 let coerce = if blk.targeted_by_break {
4497 CoerceMany::new(coerce_to_ty)
4499 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4500 Some(e) => slice::from_ref(e),
4503 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4506 let prev_diverges = self.diverges.get();
4507 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4509 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4510 for s in blk.stmts {
4514 // check the tail expression **without** holding the
4515 // `enclosing_breakables` lock below.
4516 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4518 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4519 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4520 let coerce = ctxt.coerce.as_mut().unwrap();
4521 if let Some(tail_expr_ty) = tail_expr_ty {
4522 let tail_expr = tail_expr.unwrap();
4523 let span = self.get_expr_coercion_span(tail_expr);
4524 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4525 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4527 // Subtle: if there is no explicit tail expression,
4528 // that is typically equivalent to a tail expression
4529 // of `()` -- except if the block diverges. In that
4530 // case, there is no value supplied from the tail
4531 // expression (assuming there are no other breaks,
4532 // this implies that the type of the block will be
4535 // #41425 -- label the implicit `()` as being the
4536 // "found type" here, rather than the "expected type".
4537 if !self.diverges.get().is_always() {
4538 // #50009 -- Do not point at the entire fn block span, point at the return type
4539 // span, as it is the cause of the requirement, and
4540 // `consider_hint_about_removing_semicolon` will point at the last expression
4541 // if it were a relevant part of the error. This improves usability in editors
4542 // that highlight errors inline.
4543 let mut sp = blk.span;
4544 let mut fn_span = None;
4545 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4546 let ret_sp = decl.output.span();
4547 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4548 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4549 // output would otherwise be incorrect and even misleading. Make sure
4550 // the span we're aiming at correspond to a `fn` body.
4551 if block_sp == blk.span {
4553 fn_span = Some(ident.span);
4557 coerce.coerce_forced_unit(
4561 if let Some(expected_ty) = expected.only_has_type(self) {
4562 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4564 if let Some(fn_span) = fn_span {
4567 "implicitly returns `()` as its body has no tail or `return` \
4579 // If we can break from the block, then the block's exit is always reachable
4580 // (... as long as the entry is reachable) - regardless of the tail of the block.
4581 self.diverges.set(prev_diverges);
4584 let mut ty = ctxt.coerce.unwrap().complete(self);
4586 if self.has_errors.get() || ty.references_error() {
4587 ty = self.tcx.types.err
4590 self.write_ty(blk.hir_id, ty);
4592 *self.ps.borrow_mut() = prev;
4596 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4597 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4599 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4600 | Node::ImplItem(&hir::ImplItem {
4601 kind: hir::ImplItemKind::Method(_, body_id), ..
4603 let body = self.tcx.hir().body(body_id);
4604 if let ExprKind::Block(block, _) = &body.value.kind {
4605 return Some(block.span);
4613 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4614 fn get_parent_fn_decl(
4617 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident)> {
4618 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4619 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4622 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4623 fn get_node_fn_decl(
4626 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident, bool)> {
4628 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4629 // This is less than ideal, it will not suggest a return type span on any
4630 // method called `main`, regardless of whether it is actually the entry point,
4631 // but it will still present it as the reason for the expected type.
4632 Some((&sig.decl, ident, ident.name != sym::main))
4634 Node::TraitItem(&hir::TraitItem {
4636 kind: hir::TraitItemKind::Method(ref sig, ..),
4638 }) => Some((&sig.decl, ident, true)),
4639 Node::ImplItem(&hir::ImplItem {
4641 kind: hir::ImplItemKind::Method(ref sig, ..),
4643 }) => Some((&sig.decl, ident, false)),
4648 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4649 /// suggestion can be made, `None` otherwise.
4650 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4651 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4652 // `while` before reaching it, as block tail returns are not available in them.
4653 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4654 let parent = self.tcx.hir().get(blk_id);
4655 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4659 /// On implicit return expressions with mismatched types, provides the following suggestions:
4661 /// - Points out the method's return type as the reason for the expected type.
4662 /// - Possible missing semicolon.
4663 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4664 pub fn suggest_mismatched_types_on_tail(
4666 err: &mut DiagnosticBuilder<'_>,
4667 expr: &'tcx hir::Expr<'tcx>,
4673 let expr = expr.peel_drop_temps();
4674 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4675 let mut pointing_at_return_type = false;
4676 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4677 pointing_at_return_type =
4678 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4680 pointing_at_return_type
4683 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4684 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4686 /// fn foo(x: usize) -> usize { x }
4687 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4691 err: &mut DiagnosticBuilder<'_>,
4692 expr: &hir::Expr<'_>,
4696 let hir = self.tcx.hir();
4697 let (def_id, sig) = match found.kind {
4698 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4699 ty::Closure(def_id, substs) => {
4700 // We don't use `closure_sig` to account for malformed closures like
4701 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4702 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4705 match closure_sig_ty.kind {
4706 ty::FnPtr(sig) => sig,
4714 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4715 let sig = self.normalize_associated_types_in(expr.span, &sig);
4716 if self.can_coerce(sig.output(), expected) {
4717 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4718 (String::new(), Applicability::MachineApplicable)
4720 ("...".to_string(), Applicability::HasPlaceholders)
4722 let mut msg = "call this function";
4723 match hir.get_if_local(def_id) {
4724 Some(Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. }))
4725 | Some(Node::ImplItem(hir::ImplItem {
4726 kind: hir::ImplItemKind::Method(_, body_id),
4729 | Some(Node::TraitItem(hir::TraitItem {
4730 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4733 let body = hir.body(*body_id);
4737 .map(|param| match ¶m.pat.kind {
4738 hir::PatKind::Binding(_, _, ident, None)
4739 if ident.name != kw::SelfLower =>
4743 _ => "_".to_string(),
4745 .collect::<Vec<_>>()
4748 Some(Node::Expr(hir::Expr {
4749 kind: ExprKind::Closure(_, _, body_id, _, _),
4750 span: full_closure_span,
4753 if *full_closure_span == expr.span {
4756 msg = "call this closure";
4757 let body = hir.body(*body_id);
4761 .map(|param| match ¶m.pat.kind {
4762 hir::PatKind::Binding(_, _, ident, None)
4763 if ident.name != kw::SelfLower =>
4767 _ => "_".to_string(),
4769 .collect::<Vec<_>>()
4772 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4773 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4774 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4775 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4776 msg = "instantiate this tuple variant";
4778 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4779 msg = "instantiate this tuple struct";
4784 Some(Node::ForeignItem(hir::ForeignItem {
4785 kind: hir::ForeignItemKind::Fn(_, idents, _),
4791 if ident.name != kw::SelfLower {
4797 .collect::<Vec<_>>()
4800 Some(Node::TraitItem(hir::TraitItem {
4801 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4807 if ident.name != kw::SelfLower {
4813 .collect::<Vec<_>>()
4818 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4819 err.span_suggestion(
4821 &format!("use parentheses to {}", msg),
4822 format!("{}({})", code, sugg_call),
4831 pub fn suggest_ref_or_into(
4833 err: &mut DiagnosticBuilder<'_>,
4834 expr: &hir::Expr<'_>,
4838 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4839 err.span_suggestion(sp, msg, suggestion, Applicability::MachineApplicable);
4840 } else if let (ty::FnDef(def_id, ..), true) =
4841 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
4843 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4844 let sp = self.sess().source_map().def_span(sp);
4845 err.span_label(sp, &format!("{} defined here", found));
4847 } else if !self.check_for_cast(err, expr, found, expected) {
4848 let is_struct_pat_shorthand_field =
4849 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
4850 let methods = self.get_conversion_methods(expr.span, expected, found);
4851 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4852 let mut suggestions = iter::repeat(&expr_text)
4853 .zip(methods.iter())
4854 .filter_map(|(receiver, method)| {
4855 let method_call = format!(".{}()", method.ident);
4856 if receiver.ends_with(&method_call) {
4857 None // do not suggest code that is already there (#53348)
4859 let method_call_list = [".to_vec()", ".to_string()"];
4860 let sugg = if receiver.ends_with(".clone()")
4861 && method_call_list.contains(&method_call.as_str())
4863 let max_len = receiver.rfind(".").unwrap();
4864 format!("{}{}", &receiver[..max_len], method_call)
4866 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
4867 format!("({}){}", receiver, method_call)
4869 format!("{}{}", receiver, method_call)
4872 Some(if is_struct_pat_shorthand_field {
4873 format!("{}: {}", receiver, sugg)
4880 if suggestions.peek().is_some() {
4881 err.span_suggestions(
4883 "try using a conversion method",
4885 Applicability::MaybeIncorrect,
4892 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4893 /// in the heap by calling `Box::new()`.
4894 fn suggest_boxing_when_appropriate(
4896 err: &mut DiagnosticBuilder<'_>,
4897 expr: &hir::Expr<'_>,
4901 if self.tcx.hir().is_const_context(expr.hir_id) {
4902 // Do not suggest `Box::new` in const context.
4905 if !expected.is_box() || found.is_box() {
4908 let boxed_found = self.tcx.mk_box(found);
4909 if let (true, Ok(snippet)) = (
4910 self.can_coerce(boxed_found, expected),
4911 self.sess().source_map().span_to_snippet(expr.span),
4913 err.span_suggestion(
4915 "store this in the heap by calling `Box::new`",
4916 format!("Box::new({})", snippet),
4917 Applicability::MachineApplicable,
4920 "for more on the distinction between the stack and the \
4921 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4922 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4923 https://doc.rust-lang.org/std/boxed/index.html",
4928 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4932 /// bar_that_returns_u32()
4936 /// This routine checks if the return expression in a block would make sense on its own as a
4937 /// statement and the return type has been left as default or has been specified as `()`. If so,
4938 /// it suggests adding a semicolon.
4939 fn suggest_missing_semicolon(
4941 err: &mut DiagnosticBuilder<'_>,
4942 expression: &'tcx hir::Expr<'tcx>,
4946 if expected.is_unit() {
4947 // `BlockTailExpression` only relevant if the tail expr would be
4948 // useful on its own.
4949 match expression.kind {
4951 | ExprKind::MethodCall(..)
4952 | ExprKind::Loop(..)
4953 | ExprKind::Match(..)
4954 | ExprKind::Block(..) => {
4955 err.span_suggestion(
4956 cause_span.shrink_to_hi(),
4957 "try adding a semicolon",
4959 Applicability::MachineApplicable,
4967 fn is_unsized_return(&self, blk_id: hir::HirId) -> bool {
4968 if let Some((fn_decl, _)) = self.get_fn_decl(blk_id) {
4969 if let hir::FunctionRetTy::Return(ty) = fn_decl.output {
4970 let ty = AstConv::ast_ty_to_ty(self, ty);
4971 if let ty::Dynamic(..) = ty.kind {
4979 /// A possible error is to forget to add a return type that is needed:
4983 /// bar_that_returns_u32()
4987 /// This routine checks if the return type is left as default, the method is not part of an
4988 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4990 fn suggest_missing_return_type(
4992 err: &mut DiagnosticBuilder<'_>,
4993 fn_decl: &hir::FnDecl<'_>,
4998 // Only suggest changing the return type for methods that
4999 // haven't set a return type at all (and aren't `fn main()` or an impl).
5000 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5001 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5002 err.span_suggestion(
5004 "try adding a return type",
5005 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5006 Applicability::MachineApplicable,
5010 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5011 err.span_label(span, "possibly return type missing here?");
5014 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5015 // `fn main()` must return `()`, do not suggest changing return type
5016 err.span_label(span, "expected `()` because of default return type");
5019 // expectation was caused by something else, not the default return
5020 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5021 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5022 // Only point to return type if the expected type is the return type, as if they
5023 // are not, the expectation must have been caused by something else.
5024 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5026 let ty = AstConv::ast_ty_to_ty(self, ty);
5027 debug!("suggest_missing_return_type: return type {:?}", ty);
5028 debug!("suggest_missing_return_type: expected type {:?}", ty);
5029 if ty.kind == expected.kind {
5030 err.span_label(sp, format!("expected `{}` because of return type", expected));
5038 /// A possible error is to forget to add `.await` when using futures:
5041 /// async fn make_u32() -> u32 {
5045 /// fn take_u32(x: u32) {}
5047 /// async fn foo() {
5048 /// let x = make_u32();
5053 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5054 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5055 /// `.await` to the tail of the expression.
5056 fn suggest_missing_await(
5058 err: &mut DiagnosticBuilder<'_>,
5059 expr: &hir::Expr<'_>,
5063 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5064 // body isn't `async`.
5065 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5066 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5067 let body = self.tcx().hir().body(body_id);
5068 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5070 // Check for `Future` implementations by constructing a predicate to
5071 // prove: `<T as Future>::Output == U`
5072 let future_trait = self.tcx.lang_items().future_trait().unwrap();
5073 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
5075 ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5076 // `<T as Future>::Output`
5077 projection_ty: ty::ProjectionTy {
5079 substs: self.tcx.mk_substs_trait(
5081 self.fresh_substs_for_item(sp, item_def_id),
5088 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5089 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5090 if self.infcx.predicate_may_hold(&obligation) {
5091 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5092 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5093 err.span_suggestion(
5095 "consider using `.await` here",
5096 format!("{}.await", code),
5097 Applicability::MaybeIncorrect,
5100 debug!("suggest_missing_await: no snippet for {:?}", sp);
5103 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5109 /// A common error is to add an extra semicolon:
5112 /// fn foo() -> usize {
5117 /// This routine checks if the final statement in a block is an
5118 /// expression with an explicit semicolon whose type is compatible
5119 /// with `expected_ty`. If so, it suggests removing the semicolon.
5120 fn consider_hint_about_removing_semicolon(
5122 blk: &'tcx hir::Block<'tcx>,
5123 expected_ty: Ty<'tcx>,
5124 err: &mut DiagnosticBuilder<'_>,
5126 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5127 err.span_suggestion(
5129 "consider removing this semicolon",
5131 Applicability::MachineApplicable,
5136 fn could_remove_semicolon(
5138 blk: &'tcx hir::Block<'tcx>,
5139 expected_ty: Ty<'tcx>,
5141 // Be helpful when the user wrote `{... expr;}` and
5142 // taking the `;` off is enough to fix the error.
5143 let last_stmt = blk.stmts.last()?;
5144 let last_expr = match last_stmt.kind {
5145 hir::StmtKind::Semi(ref e) => e,
5148 let last_expr_ty = self.node_ty(last_expr.hir_id);
5149 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5152 let original_span = original_sp(last_stmt.span, blk.span);
5153 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5156 // Instantiates the given path, which must refer to an item with the given
5157 // number of type parameters and type.
5158 pub fn instantiate_value_path(
5160 segments: &[hir::PathSegment<'_>],
5161 self_ty: Option<Ty<'tcx>>,
5165 ) -> (Ty<'tcx>, Res) {
5167 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5168 segments, self_ty, res, hir_id,
5173 let path_segs = match res {
5174 Res::Local(_) | Res::SelfCtor(_) => vec![],
5175 Res::Def(kind, def_id) => {
5176 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5178 _ => bug!("instantiate_value_path on {:?}", res),
5181 let mut user_self_ty = None;
5182 let mut is_alias_variant_ctor = false;
5184 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5185 if let Some(self_ty) = self_ty {
5186 let adt_def = self_ty.ty_adt_def().unwrap();
5187 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5188 is_alias_variant_ctor = true;
5191 Res::Def(DefKind::Method, def_id) | Res::Def(DefKind::AssocConst, def_id) => {
5192 let container = tcx.associated_item(def_id).container;
5193 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5195 ty::TraitContainer(trait_did) => {
5196 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5198 ty::ImplContainer(impl_def_id) => {
5199 if segments.len() == 1 {
5200 // `<T>::assoc` will end up here, and so
5201 // can `T::assoc`. It this came from an
5202 // inherent impl, we need to record the
5203 // `T` for posterity (see `UserSelfTy` for
5205 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5206 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5214 // Now that we have categorized what space the parameters for each
5215 // segment belong to, let's sort out the parameters that the user
5216 // provided (if any) into their appropriate spaces. We'll also report
5217 // errors if type parameters are provided in an inappropriate place.
5219 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5220 let generics_has_err = AstConv::prohibit_generics(
5222 segments.iter().enumerate().filter_map(|(index, seg)| {
5223 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5231 if let Res::Local(hid) = res {
5232 let ty = self.local_ty(span, hid).decl_ty;
5233 let ty = self.normalize_associated_types_in(span, &ty);
5234 self.write_ty(hir_id, ty);
5238 if generics_has_err {
5239 // Don't try to infer type parameters when prohibited generic arguments were given.
5240 user_self_ty = None;
5243 // Now we have to compare the types that the user *actually*
5244 // provided against the types that were *expected*. If the user
5245 // did not provide any types, then we want to substitute inference
5246 // variables. If the user provided some types, we may still need
5247 // to add defaults. If the user provided *too many* types, that's
5250 let mut infer_args_for_err = FxHashSet::default();
5251 for &PathSeg(def_id, index) in &path_segs {
5252 let seg = &segments[index];
5253 let generics = tcx.generics_of(def_id);
5254 // Argument-position `impl Trait` is treated as a normal generic
5255 // parameter internally, but we don't allow users to specify the
5256 // parameter's value explicitly, so we have to do some error-
5258 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5259 tcx, span, &generics, &seg, false, // `is_method_call`
5261 if suppress_errors {
5262 infer_args_for_err.insert(index);
5263 self.set_tainted_by_errors(); // See issue #53251.
5267 let has_self = path_segs
5269 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5272 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5273 let ty = self.impl_self_ty(span, impl_def_id).ty;
5274 let adt_def = ty.ty_adt_def();
5277 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5278 let variant = adt_def.non_enum_variant();
5279 let ctor_def_id = variant.ctor_def_id.unwrap();
5281 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5286 let mut err = tcx.sess.struct_span_err(
5288 "the `Self` constructor can only be used with tuple or unit structs",
5290 if let Some(adt_def) = adt_def {
5291 match adt_def.adt_kind() {
5293 err.help("did you mean to use one of the enum's variants?");
5295 AdtKind::Struct | AdtKind::Union => {
5296 err.span_suggestion(
5298 "use curly brackets",
5299 String::from("Self { /* fields */ }"),
5300 Applicability::HasPlaceholders,
5307 return (tcx.types.err, res);
5313 let def_id = res.def_id();
5315 // The things we are substituting into the type should not contain
5316 // escaping late-bound regions, and nor should the base type scheme.
5317 let ty = tcx.type_of(def_id);
5319 let substs = self_ctor_substs.unwrap_or_else(|| {
5320 AstConv::create_substs_for_generic_args(
5326 // Provide the generic args, and whether types should be inferred.
5328 if let Some(&PathSeg(_, index)) =
5329 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5331 // If we've encountered an `impl Trait`-related error, we're just
5332 // going to infer the arguments for better error messages.
5333 if !infer_args_for_err.contains(&index) {
5334 // Check whether the user has provided generic arguments.
5335 if let Some(ref data) = segments[index].args {
5336 return (Some(data), segments[index].infer_args);
5339 return (None, segments[index].infer_args);
5344 // Provide substitutions for parameters for which (valid) arguments have been provided.
5345 |param, arg| match (¶m.kind, arg) {
5346 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5347 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5349 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5350 self.to_ty(ty).into()
5352 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5353 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5355 _ => unreachable!(),
5357 // Provide substitutions for parameters for which arguments are inferred.
5358 |substs, param, infer_args| {
5360 GenericParamDefKind::Lifetime => {
5361 self.re_infer(Some(param), span).unwrap().into()
5363 GenericParamDefKind::Type { has_default, .. } => {
5364 if !infer_args && has_default {
5365 // If we have a default, then we it doesn't matter that we're not
5366 // inferring the type arguments: we provide the default where any
5368 let default = tcx.type_of(param.def_id);
5371 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5375 // If no type arguments were provided, we have to infer them.
5376 // This case also occurs as a result of some malformed input, e.g.
5377 // a lifetime argument being given instead of a type parameter.
5378 // Using inference instead of `Error` gives better error messages.
5379 self.var_for_def(span, param)
5382 GenericParamDefKind::Const => {
5383 // FIXME(const_generics:defaults)
5384 // No const parameters were provided, we have to infer them.
5385 self.var_for_def(span, param)
5391 assert!(!substs.has_escaping_bound_vars());
5392 assert!(!ty.has_escaping_bound_vars());
5394 // First, store the "user substs" for later.
5395 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5397 self.add_required_obligations(span, def_id, &substs);
5399 // Substitute the values for the type parameters into the type of
5400 // the referenced item.
5401 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5403 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5404 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5405 // is inherent, there is no `Self` parameter; instead, the impl needs
5406 // type parameters, which we can infer by unifying the provided `Self`
5407 // with the substituted impl type.
5408 // This also occurs for an enum variant on a type alias.
5409 let ty = tcx.type_of(impl_def_id);
5411 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5412 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5413 Ok(ok) => self.register_infer_ok_obligations(ok),
5415 self.tcx.sess.delay_span_bug(span, &format!(
5416 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5424 self.check_rustc_args_require_const(def_id, hir_id, span);
5426 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5427 self.write_substs(hir_id, substs);
5429 (ty_substituted, res)
5432 /// Add all the obligations that are required, substituting and normalized appropriately.
5433 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5434 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5436 for (i, mut obligation) in traits::predicates_for_generics(
5437 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5444 // This makes the error point at the bound, but we want to point at the argument
5445 if let Some(span) = spans.get(i) {
5446 obligation.cause.code = traits::BindingObligation(def_id, *span);
5448 self.register_predicate(obligation);
5452 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5453 // We're only interested in functions tagged with
5454 // #[rustc_args_required_const], so ignore anything that's not.
5455 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5459 // If our calling expression is indeed the function itself, we're good!
5460 // If not, generate an error that this can only be called directly.
5461 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5462 if let ExprKind::Call(ref callee, ..) = expr.kind {
5463 if callee.hir_id == hir_id {
5469 self.tcx.sess.span_err(
5471 "this function can only be invoked \
5472 directly, not through a function pointer",
5476 /// Resolves `typ` by a single level if `typ` is a type variable.
5477 /// If no resolution is possible, then an error is reported.
5478 /// Numeric inference variables may be left unresolved.
5479 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5480 let ty = self.resolve_vars_with_obligations(ty);
5481 if !ty.is_ty_var() {
5484 if !self.is_tainted_by_errors() {
5485 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5486 .note("type must be known at this point")
5489 self.demand_suptype(sp, self.tcx.types.err, ty);
5494 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5497 ctxt: BreakableCtxt<'tcx>,
5499 ) -> (BreakableCtxt<'tcx>, R) {
5502 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5503 index = enclosing_breakables.stack.len();
5504 enclosing_breakables.by_id.insert(id, index);
5505 enclosing_breakables.stack.push(ctxt);
5509 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5510 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5511 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5512 enclosing_breakables.stack.pop().expect("missing breakable context")
5517 /// Instantiate a QueryResponse in a probe context, without a
5518 /// good ObligationCause.
5519 fn probe_instantiate_query_response(
5522 original_values: &OriginalQueryValues<'tcx>,
5523 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5524 ) -> InferResult<'tcx, Ty<'tcx>> {
5525 self.instantiate_query_response_and_region_obligations(
5526 &traits::ObligationCause::misc(span, self.body_id),
5533 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5534 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5535 let mut contained_in_place = false;
5537 while let hir::Node::Expr(parent_expr) =
5538 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5540 match &parent_expr.kind {
5541 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5542 if lhs.hir_id == expr_id {
5543 contained_in_place = true;
5549 expr_id = parent_expr.hir_id;
5556 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5557 let own_counts = generics.own_counts();
5559 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5560 own_counts.types, own_counts.consts, ty
5563 if own_counts.types == 0 {
5567 // Make a vector of booleans initially `false`; set to `true` when used.
5568 let mut types_used = vec![false; own_counts.types];
5570 for leaf_ty in ty.walk() {
5571 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5572 debug!("found use of ty param num {}", index);
5573 types_used[index as usize - own_counts.lifetimes] = true;
5574 } else if let ty::Error = leaf_ty.kind {
5575 // If there is already another error, do not emit
5576 // an error for not using a type parameter.
5577 assert!(tcx.sess.has_errors());
5582 let types = generics.params.iter().filter(|param| match param.kind {
5583 ty::GenericParamDefKind::Type { .. } => true,
5586 for (&used, param) in types_used.iter().zip(types) {
5588 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5589 let span = tcx.hir().span(id);
5590 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5591 .span_label(span, "unused type parameter")
5597 fn fatally_break_rust(sess: &Session) {
5598 let handler = sess.diagnostic();
5599 handler.span_bug_no_panic(
5601 "It looks like you're trying to break rust; would you like some ICE?",
5603 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5604 handler.note_without_error(
5605 "we would appreciate a joke overview: \
5606 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5608 handler.note_without_error(&format!(
5609 "rustc {} running on {}",
5610 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5611 crate::session::config::host_triple(),
5615 fn potentially_plural_count(count: usize, word: &str) -> String {
5616 format!("{} {}{}", count, word, pluralize!(count))