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, Item, 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 items, .. } => {
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(tcx, it.span, impl_def_id, impl_trait_ref, items);
1717 let trait_def_id = impl_trait_ref.def_id;
1718 check_on_unimplemented(tcx, trait_def_id, it);
1721 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1722 let def_id = tcx.hir().local_def_id(it.hir_id);
1723 check_on_unimplemented(tcx, def_id, it);
1725 for item in items.iter() {
1726 let item = tcx.hir().trait_item(item.id);
1727 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1728 let abi = sig.header.abi;
1729 fn_maybe_err(tcx, item.ident.span, abi);
1733 hir::ItemKind::Struct(..) => {
1734 check_struct(tcx, it.hir_id, it.span);
1736 hir::ItemKind::Union(..) => {
1737 check_union(tcx, it.hir_id, it.span);
1739 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1740 let def_id = tcx.hir().local_def_id(it.hir_id);
1742 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1743 check_opaque(tcx, def_id, substs, it.span, &origin);
1745 hir::ItemKind::TyAlias(..) => {
1746 let def_id = tcx.hir().local_def_id(it.hir_id);
1747 let pty_ty = tcx.type_of(def_id);
1748 let generics = tcx.generics_of(def_id);
1749 check_bounds_are_used(tcx, &generics, pty_ty);
1751 hir::ItemKind::ForeignMod(ref m) => {
1752 check_abi(tcx, it.span, m.abi);
1754 if m.abi == Abi::RustIntrinsic {
1755 for item in m.items {
1756 intrinsic::check_intrinsic_type(tcx, item);
1758 } else if m.abi == Abi::PlatformIntrinsic {
1759 for item in m.items {
1760 intrinsic::check_platform_intrinsic_type(tcx, item);
1763 for item in m.items {
1764 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1765 let own_counts = generics.own_counts();
1766 if generics.params.len() - own_counts.lifetimes != 0 {
1767 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1768 (_, 0) => ("type", "types", Some("u32")),
1769 // We don't specify an example value, because we can't generate
1770 // a valid value for any type.
1771 (0, _) => ("const", "consts", None),
1772 _ => ("type or const", "types or consts", None),
1778 "foreign items may not have {} parameters",
1781 .span_label(item.span, &format!("can't have {} parameters", kinds))
1783 // FIXME: once we start storing spans for type arguments, turn this
1784 // into a suggestion.
1786 "replace the {} parameters with concrete {}{}",
1789 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1795 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1796 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1801 _ => { /* nothing to do */ }
1805 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1806 // Only restricted on wasm32 target for now
1807 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1811 // If `#[link_section]` is missing, then nothing to verify
1812 let attrs = tcx.codegen_fn_attrs(id);
1813 if attrs.link_section.is_none() {
1817 // For the wasm32 target statics with `#[link_section]` are placed into custom
1818 // sections of the final output file, but this isn't link custom sections of
1819 // other executable formats. Namely we can only embed a list of bytes,
1820 // nothing with pointers to anything else or relocations. If any relocation
1821 // show up, reject them here.
1822 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1823 // the consumer's responsibility to ensure all bytes that have been read
1824 // have defined values.
1825 if let Ok(static_) = tcx.const_eval_poly(id) {
1826 let alloc = if let ty::ConstKind::Value(ConstValue::ByRef { alloc, .. }) = static_.val {
1829 bug!("Matching on non-ByRef static")
1831 if alloc.relocations().len() != 0 {
1832 let msg = "statics with a custom `#[link_section]` must be a \
1833 simple list of bytes on the wasm target with no \
1834 extra levels of indirection such as references";
1835 tcx.sess.span_err(span, msg);
1840 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1841 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1842 // an error would be reported if this fails.
1843 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1846 fn report_forbidden_specialization(
1848 impl_item: &hir::ImplItem<'_>,
1851 let mut err = struct_span_err!(
1855 "`{}` specializes an item from a parent `impl`, but \
1856 that item is not marked `default`",
1859 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
1861 match tcx.span_of_impl(parent_impl) {
1863 err.span_label(span, "parent `impl` is here");
1865 "to specialize, `{}` in the parent `impl` must be marked `default`",
1870 err.note(&format!("parent implementation is in crate `{}`", cname));
1877 fn check_specialization_validity<'tcx>(
1879 trait_def: &ty::TraitDef,
1880 trait_item: &ty::AssocItem,
1882 impl_item: &hir::ImplItem<'_>,
1884 let kind = match impl_item.kind {
1885 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1886 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1887 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1888 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1891 let mut ancestor_impls = trait_def
1892 .ancestors(tcx, impl_id)
1894 .filter_map(|parent| {
1895 if parent.is_from_trait() {
1898 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1903 if ancestor_impls.peek().is_none() {
1904 // No parent, nothing to specialize.
1908 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1910 // Parent impl exists, and contains the parent item we're trying to specialize, but
1911 // doesn't mark it `default`.
1912 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1913 Some(Err(parent_impl.def_id()))
1916 // Parent impl contains item and makes it specializable.
1917 Some(_) => Some(Ok(())),
1919 // Parent impl doesn't mention the item. This means it's inherited from the
1920 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1921 // "defaultness" from the grandparent, else they are final.
1923 if traits::impl_is_default(tcx, parent_impl.def_id()) {
1926 Some(Err(parent_impl.def_id()))
1932 // If `opt_result` is `None`, we have only encoutered `default impl`s that don't contain the
1933 // item. This is allowed, the item isn't actually getting specialized here.
1934 let result = opt_result.unwrap_or(Ok(()));
1936 if let Err(parent_impl) = result {
1937 report_forbidden_specialization(tcx, impl_item, parent_impl);
1941 fn check_impl_items_against_trait<'tcx>(
1943 full_impl_span: Span,
1945 impl_trait_ref: ty::TraitRef<'tcx>,
1946 impl_item_refs: &[hir::ImplItemRef<'_>],
1948 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1950 // If the trait reference itself is erroneous (so the compilation is going
1951 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1952 // isn't populated for such impls.
1953 if impl_trait_ref.references_error() {
1957 // Locate trait definition and items
1958 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1959 let mut overridden_associated_type = None;
1961 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1963 // Check existing impl methods to see if they are both present in trait
1964 // and compatible with trait signature
1965 for impl_item in impl_items() {
1966 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
1967 let ty_trait_item = tcx
1968 .associated_items(impl_trait_ref.def_id)
1970 Namespace::from(&impl_item.kind) == Namespace::from(ac.kind)
1971 && tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id)
1974 // Not compatible, but needed for the error message
1975 tcx.associated_items(impl_trait_ref.def_id)
1976 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1979 // Check that impl definition matches trait definition
1980 if let Some(ty_trait_item) = ty_trait_item {
1981 match impl_item.kind {
1982 hir::ImplItemKind::Const(..) => {
1983 // Find associated const definition.
1984 if ty_trait_item.kind == ty::AssocKind::Const {
1993 let mut err = struct_span_err!(
1997 "item `{}` is an associated const, \
1998 which doesn't match its trait `{}`",
2000 impl_trait_ref.print_only_trait_path()
2002 err.span_label(impl_item.span, "does not match trait");
2003 // We can only get the spans from local trait definition
2004 // Same for E0324 and E0325
2005 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
2006 err.span_label(trait_span, "item in trait");
2011 hir::ImplItemKind::Method(..) => {
2012 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2013 if ty_trait_item.kind == ty::AssocKind::Method {
2014 compare_impl_method(
2023 let mut err = struct_span_err!(
2027 "item `{}` is an associated method, \
2028 which doesn't match its trait `{}`",
2030 impl_trait_ref.print_only_trait_path()
2032 err.span_label(impl_item.span, "does not match trait");
2033 if let Some(trait_span) = opt_trait_span {
2034 err.span_label(trait_span, "item in trait");
2039 hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {
2040 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2041 if ty_trait_item.kind == ty::AssocKind::Type {
2042 if ty_trait_item.defaultness.has_value() {
2043 overridden_associated_type = Some(impl_item);
2054 let mut err = struct_span_err!(
2058 "item `{}` is an associated type, \
2059 which doesn't match its trait `{}`",
2061 impl_trait_ref.print_only_trait_path()
2063 err.span_label(impl_item.span, "does not match trait");
2064 if let Some(trait_span) = opt_trait_span {
2065 err.span_label(trait_span, "item in trait");
2072 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2076 // Check for missing items from trait
2077 let mut missing_items = Vec::new();
2078 let mut invalidated_items = Vec::new();
2079 let associated_type_overridden = overridden_associated_type.is_some();
2080 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
2081 let is_implemented = trait_def
2082 .ancestors(tcx, impl_id)
2083 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2084 .map(|node_item| !node_item.node.is_from_trait())
2087 if !is_implemented && !traits::impl_is_default(tcx, impl_id) {
2088 if !trait_item.defaultness.has_value() {
2089 missing_items.push(trait_item);
2090 } else if associated_type_overridden {
2091 invalidated_items.push(trait_item.ident);
2096 if !missing_items.is_empty() {
2097 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2100 if !invalidated_items.is_empty() {
2101 let invalidator = overridden_associated_type.unwrap();
2106 "the following trait items need to be reimplemented as `{}` was overridden: `{}`",
2108 invalidated_items.iter().map(|name| name.to_string()).collect::<Vec<_>>().join("`, `")
2114 fn missing_items_err(
2117 missing_items: &[ty::AssocItem],
2118 full_impl_span: Span,
2120 let missing_items_msg = missing_items
2122 .map(|trait_item| trait_item.ident.to_string())
2123 .collect::<Vec<_>>()
2126 let mut err = struct_span_err!(
2130 "not all trait items implemented, missing: `{}`",
2133 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2135 // `Span` before impl block closing brace.
2136 let hi = full_impl_span.hi() - BytePos(1);
2137 // Point at the place right before the closing brace of the relevant `impl` to suggest
2138 // adding the associated item at the end of its body.
2139 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2140 // Obtain the level of indentation ending in `sugg_sp`.
2141 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2142 // Make the whitespace that will make the suggestion have the right indentation.
2143 let padding: String = (0..indentation).map(|_| " ").collect();
2145 for trait_item in missing_items {
2146 let snippet = suggestion_signature(&trait_item, tcx);
2147 let code = format!("{}{}\n{}", padding, snippet, padding);
2148 let msg = format!("implement the missing item: `{}`", snippet);
2149 let appl = Applicability::HasPlaceholders;
2150 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2151 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2152 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2154 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2160 /// Return placeholder code for the given function.
2161 fn fn_sig_suggestion(sig: &ty::FnSig<'_>, ident: Ident) -> String {
2166 Some(match ty.kind {
2167 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2168 ty::Ref(reg, ref_ty, mutability) => {
2169 let reg = match &format!("{}", reg)[..] {
2170 "'_" | "" => String::new(),
2171 reg => format!("{} ", reg),
2174 ty::Param(param) if param.name == kw::SelfUpper => {
2175 format!("&{}{}self", reg, mutability.prefix_str())
2177 _ => format!("_: {:?}", ty),
2180 _ => format!("_: {:?}", ty),
2183 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2184 .filter_map(|arg| arg)
2185 .collect::<Vec<String>>()
2187 let output = sig.output();
2188 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2190 let unsafety = sig.unsafety.prefix_str();
2191 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2192 // not be present in the `fn` definition, not will we account for renamed
2193 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2194 // fill in a significant portion of the missing code, and other subsequent
2195 // suggestions can help the user fix the code.
2196 format!("{}fn {}({}){} {{ unimplemented!() }}", unsafety, ident, args, output)
2199 /// Return placeholder code for the given associated item.
2200 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2201 /// structured suggestion.
2202 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2204 ty::AssocKind::Method => {
2205 // We skip the binder here because the binder would deanonymize all
2206 // late-bound regions, and we don't want method signatures to show up
2207 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2208 // regions just fine, showing `fn(&MyType)`.
2209 fn_sig_suggestion(tcx.fn_sig(assoc.def_id).skip_binder(), assoc.ident)
2211 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2212 // FIXME(type_alias_impl_trait): we should print bounds here too.
2213 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2214 ty::AssocKind::Const => {
2215 let ty = tcx.type_of(assoc.def_id);
2216 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2217 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2222 /// Checks whether a type can be represented in memory. In particular, it
2223 /// identifies types that contain themselves without indirection through a
2224 /// pointer, which would mean their size is unbounded.
2225 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2226 let rty = tcx.type_of(item_def_id);
2228 // Check that it is possible to represent this type. This call identifies
2229 // (1) types that contain themselves and (2) types that contain a different
2230 // recursive type. It is only necessary to throw an error on those that
2231 // contain themselves. For case 2, there must be an inner type that will be
2232 // caught by case 1.
2233 match rty.is_representable(tcx, sp) {
2234 Representability::SelfRecursive(spans) => {
2235 let mut err = recursive_type_with_infinite_size_error(tcx, item_def_id);
2237 err.span_label(span, "recursive without indirection");
2242 Representability::Representable | Representability::ContainsRecursive => (),
2247 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2248 let t = tcx.type_of(def_id);
2249 if let ty::Adt(def, substs) = t.kind {
2250 if def.is_struct() {
2251 let fields = &def.non_enum_variant().fields;
2252 if fields.is_empty() {
2253 struct_span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty").emit();
2256 let e = fields[0].ty(tcx, substs);
2257 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2258 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2259 .span_label(sp, "SIMD elements must have the same type")
2264 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2265 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2271 "SIMD vector element type should be machine type"
2281 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2282 let repr = tcx.adt_def(def_id).repr;
2284 for attr in tcx.get_attrs(def_id).iter() {
2285 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2286 if let attr::ReprPacked(pack) = r {
2287 if let Some(repr_pack) = repr.pack {
2288 if pack as u64 != repr_pack.bytes() {
2293 "type has conflicting packed representation hints"
2301 if repr.align.is_some() {
2306 "type has conflicting packed and align representation hints"
2310 if let Some(def_spans) = check_packed_inner(tcx, def_id, &mut vec![]) {
2311 let mut err = struct_span_err!(
2315 "packed type cannot transitively contain a `#[repr(align)]` type"
2318 let hir = tcx.hir();
2319 if let Some(hir_id) = hir.as_local_hir_id(def_spans[0].0) {
2320 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2322 tcx.def_span(def_spans[0].0),
2323 &format!("`{}` has a `#[repr(align)]` attribute", ident),
2328 if def_spans.len() > 2 {
2329 let mut first = true;
2330 for (adt_def, span) in def_spans.iter().skip(1).rev() {
2331 if let Some(hir_id) = hir.as_local_hir_id(*adt_def) {
2332 if let Node::Item(Item { ident, .. }) = hir.get(hir_id) {
2337 "`{}` contains a field of type `{}`",
2338 tcx.type_of(def_id),
2342 format!("...which contains a field of type `{}`", ident)
2357 fn check_packed_inner(
2360 stack: &mut Vec<DefId>,
2361 ) -> Option<Vec<(DefId, Span)>> {
2362 if let ty::Adt(def, substs) = tcx.type_of(def_id).kind {
2363 if def.is_struct() || def.is_union() {
2364 if def.repr.align.is_some() {
2365 return Some(vec![(def.did, DUMMY_SP)]);
2369 for field in &def.non_enum_variant().fields {
2370 if let ty::Adt(def, _) = field.ty(tcx, substs).kind {
2371 if !stack.contains(&def.did) {
2372 if let Some(mut defs) = check_packed_inner(tcx, def.did, stack) {
2373 defs.push((def.did, field.ident.span));
2386 /// Emit an error when encountering more or less than one variant in a transparent enum.
2387 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2388 let variant_spans: Vec<_> = adt
2391 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2393 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2394 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2395 err.span_label(sp, &msg);
2396 if let [start @ .., end] = &*variant_spans {
2397 for variant_span in start {
2398 err.span_label(*variant_span, "");
2400 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2405 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2407 fn bad_non_zero_sized_fields<'tcx>(
2409 adt: &'tcx ty::AdtDef,
2411 field_spans: impl Iterator<Item = Span>,
2414 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2415 let mut err = struct_span_err!(
2419 "{}transparent {} {}",
2420 if adt.is_enum() { "the variant of a " } else { "" },
2424 err.span_label(sp, &msg);
2425 for sp in field_spans {
2426 err.span_label(sp, "this field is non-zero-sized");
2431 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2432 let adt = tcx.adt_def(def_id);
2433 if !adt.repr.transparent() {
2436 let sp = tcx.sess.source_map().def_span(sp);
2438 if adt.is_enum() && !tcx.features().transparent_enums {
2440 &tcx.sess.parse_sess,
2441 sym::transparent_enums,
2443 "transparent enums are unstable",
2448 if adt.is_union() && !tcx.features().transparent_unions {
2450 &tcx.sess.parse_sess,
2451 sym::transparent_unions,
2453 "transparent unions are unstable",
2458 if adt.variants.len() != 1 {
2459 bad_variant_count(tcx, adt, sp, def_id);
2460 if adt.variants.is_empty() {
2461 // Don't bother checking the fields. No variants (and thus no fields) exist.
2466 // For each field, figure out if it's known to be a ZST and align(1)
2467 let field_infos = adt.all_fields().map(|field| {
2468 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2469 let param_env = tcx.param_env(field.did);
2470 let layout = tcx.layout_of(param_env.and(ty));
2471 // We are currently checking the type this field came from, so it must be local
2472 let span = tcx.hir().span_if_local(field.did).unwrap();
2473 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2474 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2478 let non_zst_fields =
2479 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2480 let non_zst_count = non_zst_fields.clone().count();
2481 if non_zst_count != 1 {
2482 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2484 for (span, zst, align1) in field_infos {
2490 "zero-sized field in transparent {} has alignment larger than 1",
2493 .span_label(span, "has alignment larger than 1")
2499 #[allow(trivial_numeric_casts)]
2500 pub fn check_enum<'tcx>(
2503 vs: &'tcx [hir::Variant<'tcx>],
2506 let def_id = tcx.hir().local_def_id(id);
2507 let def = tcx.adt_def(def_id);
2508 def.destructor(tcx); // force the destructor to be evaluated
2511 let attributes = tcx.get_attrs(def_id);
2512 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2517 "unsupported representation for zero-variant enum"
2519 .span_label(sp, "zero-variant enum")
2524 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2525 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2526 if !tcx.features().repr128 {
2528 &tcx.sess.parse_sess,
2531 "repr with 128-bit type is unstable",
2538 if let Some(ref e) = v.disr_expr {
2539 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2543 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2544 let is_unit = |var: &hir::Variant<'_>| match var.data {
2545 hir::VariantData::Unit(..) => true,
2549 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2550 let has_non_units = vs.iter().any(|var| !is_unit(var));
2551 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2552 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2554 if disr_non_unit || (disr_units && has_non_units) {
2556 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2561 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2562 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2563 // Check for duplicate discriminant values
2564 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2565 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2566 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2567 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2568 let i_span = match variant_i.disr_expr {
2569 Some(ref expr) => tcx.hir().span(expr.hir_id),
2570 None => tcx.hir().span(variant_i_hir_id),
2572 let span = match v.disr_expr {
2573 Some(ref expr) => tcx.hir().span(expr.hir_id),
2580 "discriminant value `{}` already exists",
2583 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2584 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2587 disr_vals.push(discr);
2590 check_representable(tcx, sp, def_id);
2591 check_transparent(tcx, sp, def_id);
2594 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath<'_>) {
2599 "expected unit struct, unit variant or constant, found {} `{}`",
2601 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false))
2606 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2607 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2611 fn item_def_id(&self) -> Option<DefId> {
2615 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2617 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2618 let item_id = tcx.hir().ty_param_owner(hir_id);
2619 let item_def_id = tcx.hir().local_def_id(item_id);
2620 let generics = tcx.generics_of(item_def_id);
2621 let index = generics.param_def_id_to_index[&def_id];
2622 ty::GenericPredicates {
2624 predicates: tcx.arena.alloc_from_iter(self.param_env.caller_bounds.iter().filter_map(
2625 |&predicate| match predicate {
2626 ty::Predicate::Trait(ref data)
2627 if data.skip_binder().self_ty().is_param(index) =>
2629 // HACK(eddyb) should get the original `Span`.
2630 let span = tcx.def_span(def_id);
2631 Some((predicate, span))
2639 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2641 Some(def) => infer::EarlyBoundRegion(span, def.name),
2642 None => infer::MiscVariable(span),
2644 Some(self.next_region_var(v))
2647 fn allow_ty_infer(&self) -> bool {
2651 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2652 if let Some(param) = param {
2653 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2658 self.next_ty_var(TypeVariableOrigin {
2659 kind: TypeVariableOriginKind::TypeInference,
2668 param: Option<&ty::GenericParamDef>,
2670 ) -> &'tcx Const<'tcx> {
2671 if let Some(param) = param {
2672 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2677 self.next_const_var(
2679 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2684 fn projected_ty_from_poly_trait_ref(
2688 item_segment: &hir::PathSegment<'_>,
2689 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2691 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2693 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2697 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
2706 self.tcx().mk_projection(item_def_id, item_substs)
2709 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2710 if ty.has_escaping_bound_vars() {
2711 ty // FIXME: normalization and escaping regions
2713 self.normalize_associated_types_in(span, &ty)
2717 fn set_tainted_by_errors(&self) {
2718 self.infcx.set_tainted_by_errors()
2721 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2722 self.write_ty(hir_id, ty)
2726 /// Controls whether the arguments are tupled. This is used for the call
2729 /// Tupling means that all call-side arguments are packed into a tuple and
2730 /// passed as a single parameter. For example, if tupling is enabled, this
2733 /// fn f(x: (isize, isize))
2735 /// Can be called as:
2742 #[derive(Clone, Eq, PartialEq)]
2743 enum TupleArgumentsFlag {
2748 /// Controls how we perform fallback for unconstrained
2751 /// Do not fallback type variables to opaque types.
2753 /// Perform all possible kinds of fallback, including
2754 /// turning type variables to opaque types.
2758 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2760 inh: &'a Inherited<'a, 'tcx>,
2761 param_env: ty::ParamEnv<'tcx>,
2762 body_id: hir::HirId,
2763 ) -> FnCtxt<'a, 'tcx> {
2767 err_count_on_creation: inh.tcx.sess.err_count(),
2769 ret_coercion_span: RefCell::new(None),
2771 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
2772 diverges: Cell::new(Diverges::Maybe),
2773 has_errors: Cell::new(false),
2774 enclosing_breakables: RefCell::new(EnclosingBreakables {
2776 by_id: Default::default(),
2782 pub fn sess(&self) -> &Session {
2786 pub fn errors_reported_since_creation(&self) -> bool {
2787 self.tcx.sess.err_count() > self.err_count_on_creation
2790 /// Produces warning on the given node, if the current point in the
2791 /// function is unreachable, and there hasn't been another warning.
2792 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2793 // FIXME: Combine these two 'if' expressions into one once
2794 // let chains are implemented
2795 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2796 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2797 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2798 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2799 if !span.is_desugaring(DesugaringKind::CondTemporary)
2800 && !span.is_desugaring(DesugaringKind::Async)
2801 && !orig_span.is_desugaring(DesugaringKind::Await)
2803 self.diverges.set(Diverges::WarnedAlways);
2805 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2807 let msg = format!("unreachable {}", kind);
2809 .struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2810 .span_label(span, &msg)
2813 custom_note.unwrap_or("any code following this expression is unreachable"),
2820 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
2821 ObligationCause::new(span, self.body_id, code)
2824 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2825 self.cause(span, ObligationCauseCode::MiscObligation)
2828 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2829 /// version (resolve_vars_if_possible), this version will
2830 /// also select obligations if it seems useful, in an effort
2831 /// to get more type information.
2832 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2833 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2835 // No Infer()? Nothing needs doing.
2836 if !ty.has_infer_types() && !ty.has_infer_consts() {
2837 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2841 // If `ty` is a type variable, see whether we already know what it is.
2842 ty = self.resolve_vars_if_possible(&ty);
2843 if !ty.has_infer_types() && !ty.has_infer_consts() {
2844 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2848 // If not, try resolving pending obligations as much as
2849 // possible. This can help substantially when there are
2850 // indirect dependencies that don't seem worth tracking
2852 self.select_obligations_where_possible(false, |_| {});
2853 ty = self.resolve_vars_if_possible(&ty);
2855 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2859 fn record_deferred_call_resolution(
2861 closure_def_id: DefId,
2862 r: DeferredCallResolution<'tcx>,
2864 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2865 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2868 fn remove_deferred_call_resolutions(
2870 closure_def_id: DefId,
2871 ) -> Vec<DeferredCallResolution<'tcx>> {
2872 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2873 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2876 pub fn tag(&self) -> String {
2877 format!("{:p}", self)
2880 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2881 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
2882 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
2887 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2889 "write_ty({:?}, {:?}) in fcx {}",
2891 self.resolve_vars_if_possible(&ty),
2894 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2896 if ty.references_error() {
2897 self.has_errors.set(true);
2898 self.set_tainted_by_errors();
2902 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2903 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2906 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2907 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2910 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
2911 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2912 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2913 self.write_substs(hir_id, method.substs);
2915 // When the method is confirmed, the `method.substs` includes
2916 // parameters from not just the method, but also the impl of
2917 // the method -- in particular, the `Self` type will be fully
2918 // resolved. However, those are not something that the "user
2919 // specified" -- i.e., those types come from the inferred type
2920 // of the receiver, not something the user wrote. So when we
2921 // create the user-substs, we want to replace those earlier
2922 // types with just the types that the user actually wrote --
2923 // that is, those that appear on the *method itself*.
2925 // As an example, if the user wrote something like
2926 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2927 // type of `foo` (possibly adjusted), but we don't want to
2928 // include that. We want just the `[_, u32]` part.
2929 if !method.substs.is_noop() {
2930 let method_generics = self.tcx.generics_of(method.def_id);
2931 if !method_generics.params.is_empty() {
2932 let user_type_annotation = self.infcx.probe(|_| {
2933 let user_substs = UserSubsts {
2934 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2935 let i = param.index as usize;
2936 if i < method_generics.parent_count {
2937 self.infcx.var_for_def(DUMMY_SP, param)
2942 user_self_ty: None, // not relevant here
2945 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2951 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2952 self.write_user_type_annotation(hir_id, user_type_annotation);
2957 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2958 if !substs.is_noop() {
2959 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
2961 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2965 /// Given the substs that we just converted from the HIR, try to
2966 /// canonicalize them and store them as user-given substitutions
2967 /// (i.e., substitutions that must be respected by the NLL check).
2969 /// This should be invoked **before any unifications have
2970 /// occurred**, so that annotations like `Vec<_>` are preserved
2972 pub fn write_user_type_annotation_from_substs(
2976 substs: SubstsRef<'tcx>,
2977 user_self_ty: Option<UserSelfTy<'tcx>>,
2980 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2981 user_self_ty={:?} in fcx {}",
2989 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2990 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2992 UserSubsts { substs, user_self_ty },
2994 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2995 self.write_user_type_annotation(hir_id, canonicalized);
2999 pub fn write_user_type_annotation(
3002 canonical_user_type_annotation: CanonicalUserType<'tcx>,
3005 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
3007 canonical_user_type_annotation,
3011 if !canonical_user_type_annotation.is_identity() {
3014 .user_provided_types_mut()
3015 .insert(hir_id, canonical_user_type_annotation);
3017 debug!("write_user_type_annotation: skipping identity substs");
3021 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
3022 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
3028 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
3029 Entry::Vacant(entry) => {
3032 Entry::Occupied(mut entry) => {
3033 debug!(" - composing on top of {:?}", entry.get());
3034 match (&entry.get()[..], &adj[..]) {
3035 // Applying any adjustment on top of a NeverToAny
3036 // is a valid NeverToAny adjustment, because it can't
3038 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
3040 Adjustment { kind: Adjust::Deref(_), .. },
3041 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
3043 Adjustment { kind: Adjust::Deref(_), .. },
3044 .. // Any following adjustments are allowed.
3046 // A reborrow has no effect before a dereference.
3048 // FIXME: currently we never try to compose autoderefs
3049 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3051 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3052 expr, entry.get(), adj)
3054 *entry.get_mut() = adj;
3059 /// Basically whenever we are converting from a type scheme into
3060 /// the fn body space, we always want to normalize associated
3061 /// types as well. This function combines the two.
3062 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3064 T: TypeFoldable<'tcx>,
3066 let value = value.subst(self.tcx, substs);
3067 let result = self.normalize_associated_types_in(span, &value);
3068 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3072 /// As `instantiate_type_scheme`, but for the bounds found in a
3073 /// generic type scheme.
3074 fn instantiate_bounds(
3078 substs: SubstsRef<'tcx>,
3079 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3080 let bounds = self.tcx.predicates_of(def_id);
3081 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3082 let result = bounds.instantiate(self.tcx, substs);
3083 let result = self.normalize_associated_types_in(span, &result);
3085 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3086 bounds, substs, result, spans,
3091 /// Replaces the opaque types from the given value with type variables,
3092 /// and records the `OpaqueTypeMap` for later use during writeback. See
3093 /// `InferCtxt::instantiate_opaque_types` for more details.
3094 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3096 parent_id: hir::HirId,
3100 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3102 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3103 parent_def_id, value
3106 let (value, opaque_type_map) =
3107 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3115 let mut opaque_types = self.opaque_types.borrow_mut();
3116 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3117 for (ty, decl) in opaque_type_map {
3118 let _ = opaque_types.insert(ty, decl);
3119 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3125 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3127 T: TypeFoldable<'tcx>,
3129 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3132 fn normalize_associated_types_in_as_infer_ok<T>(
3136 ) -> InferOk<'tcx, T>
3138 T: TypeFoldable<'tcx>,
3140 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3143 pub fn require_type_meets(
3147 code: traits::ObligationCauseCode<'tcx>,
3150 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3153 pub fn require_type_is_sized(
3157 code: traits::ObligationCauseCode<'tcx>,
3159 if !ty.references_error() {
3160 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3161 self.require_type_meets(ty, span, code, lang_item);
3165 pub fn require_type_is_sized_deferred(
3169 code: traits::ObligationCauseCode<'tcx>,
3171 if !ty.references_error() {
3172 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3176 pub fn register_bound(
3180 cause: traits::ObligationCause<'tcx>,
3182 if !ty.references_error() {
3183 self.fulfillment_cx.borrow_mut().register_bound(
3193 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3194 let t = AstConv::ast_ty_to_ty(self, ast_t);
3195 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3199 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3200 let ty = self.to_ty(ast_ty);
3201 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3203 if Self::can_contain_user_lifetime_bounds(ty) {
3204 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3205 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3206 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3212 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3213 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3214 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3217 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3218 AstConv::ast_const_to_const(self, ast_c, ty)
3221 // If the type given by the user has free regions, save it for later, since
3222 // NLL would like to enforce those. Also pass in types that involve
3223 // projections, since those can resolve to `'static` bounds (modulo #54940,
3224 // which hopefully will be fixed by the time you see this comment, dear
3225 // reader, although I have my doubts). Also pass in types with inference
3226 // types, because they may be repeated. Other sorts of things are already
3227 // sufficiently enforced with erased regions. =)
3228 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3230 T: TypeFoldable<'tcx>,
3232 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3235 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3236 match self.tables.borrow().node_types().get(id) {
3238 None if self.is_tainted_by_errors() => self.tcx.types.err,
3241 "no type for node {}: {} in fcx {}",
3243 self.tcx.hir().node_to_string(id),
3250 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3251 /// outlive the region `r`.
3252 pub fn register_wf_obligation(
3256 code: traits::ObligationCauseCode<'tcx>,
3258 // WF obligations never themselves fail, so no real need to give a detailed cause:
3259 let cause = traits::ObligationCause::new(span, self.body_id, code);
3260 self.register_predicate(traits::Obligation::new(
3263 ty::Predicate::WellFormed(ty),
3267 /// Registers obligations that all types appearing in `substs` are well-formed.
3268 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3269 for ty in substs.types() {
3270 if !ty.references_error() {
3271 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3276 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3277 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3278 /// trait/region obligations.
3280 /// For example, if there is a function:
3283 /// fn foo<'a,T:'a>(...)
3286 /// and a reference:
3292 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3293 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3294 pub fn add_obligations_for_parameters(
3296 cause: traits::ObligationCause<'tcx>,
3297 predicates: &ty::InstantiatedPredicates<'tcx>,
3299 assert!(!predicates.has_escaping_bound_vars());
3301 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3303 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3304 self.register_predicate(obligation);
3308 // FIXME(arielb1): use this instead of field.ty everywhere
3309 // Only for fields! Returns <none> for methods>
3310 // Indifferent to privacy flags
3314 field: &'tcx ty::FieldDef,
3315 substs: SubstsRef<'tcx>,
3317 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3320 fn check_casts(&self) {
3321 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3322 for cast in deferred_cast_checks.drain(..) {
3327 fn resolve_generator_interiors(&self, def_id: DefId) {
3328 let mut generators = self.deferred_generator_interiors.borrow_mut();
3329 for (body_id, interior, kind) in generators.drain(..) {
3330 self.select_obligations_where_possible(false, |_| {});
3331 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3335 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3337 // - Unconstrained ints are replaced with `i32`.
3339 // - Unconstrained floats are replaced with with `f64`.
3341 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3342 // is enabled. Otherwise, they are replaced with `()`.
3344 // Fallback becomes very dubious if we have encountered type-checking errors.
3345 // In that case, fallback to Error.
3346 // The return value indicates whether fallback has occurred.
3347 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3348 use rustc::ty::error::UnconstrainedNumeric::Neither;
3349 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3351 assert!(ty.is_ty_infer());
3352 let fallback = match self.type_is_unconstrained_numeric(ty) {
3353 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3354 UnconstrainedInt => self.tcx.types.i32,
3355 UnconstrainedFloat => self.tcx.types.f64,
3356 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3358 // This type variable was created from the instantiation of an opaque
3359 // type. The fact that we're attempting to perform fallback for it
3360 // means that the function neither constrained it to a concrete
3361 // type, nor to the opaque type itself.
3363 // For example, in this code:
3366 // type MyType = impl Copy;
3367 // fn defining_use() -> MyType { true }
3368 // fn other_use() -> MyType { defining_use() }
3371 // `defining_use` will constrain the instantiated inference
3372 // variable to `bool`, while `other_use` will constrain
3373 // the instantiated inference variable to `MyType`.
3375 // When we process opaque types during writeback, we
3376 // will handle cases like `other_use`, and not count
3377 // them as defining usages
3379 // However, we also need to handle cases like this:
3382 // pub type Foo = impl Copy;
3383 // fn produce() -> Option<Foo> {
3388 // In the above snippet, the inference varaible created by
3389 // instantiating `Option<Foo>` will be completely unconstrained.
3390 // We treat this as a non-defining use by making the inference
3391 // variable fall back to the opaque type itself.
3392 if let FallbackMode::All = mode {
3393 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3395 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3407 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3408 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3412 fn select_all_obligations_or_error(&self) {
3413 debug!("select_all_obligations_or_error");
3414 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3415 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3419 /// Select as many obligations as we can at present.
3420 fn select_obligations_where_possible(
3422 fallback_has_occurred: bool,
3423 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3425 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3426 if let Err(mut errors) = result {
3427 mutate_fullfillment_errors(&mut errors);
3428 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3432 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3433 /// returns a type of `&T`, but the actual type we assign to the
3434 /// *expression* is `T`. So this function just peels off the return
3435 /// type by one layer to yield `T`.
3436 fn make_overloaded_place_return_type(
3438 method: MethodCallee<'tcx>,
3439 ) -> ty::TypeAndMut<'tcx> {
3440 // extract method return type, which will be &T;
3441 let ret_ty = method.sig.output();
3443 // method returns &T, but the type as visible to user is T, so deref
3444 ret_ty.builtin_deref(true).unwrap()
3449 expr: &hir::Expr<'_>,
3450 base_expr: &'tcx hir::Expr<'tcx>,
3454 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3455 // FIXME(#18741) -- this is almost but not quite the same as the
3456 // autoderef that normal method probing does. They could likely be
3459 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3460 let mut result = None;
3461 while result.is_none() && autoderef.next().is_some() {
3462 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3464 autoderef.finalize(self);
3468 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3469 /// (and otherwise adjust) `base_expr`, looking for a type which either
3470 /// supports builtin indexing or overloaded indexing.
3471 /// This loop implements one step in that search; the autoderef loop
3472 /// is implemented by `lookup_indexing`.
3475 expr: &hir::Expr<'_>,
3476 base_expr: &hir::Expr<'_>,
3477 autoderef: &Autoderef<'a, 'tcx>,
3480 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3481 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3483 "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3485 expr, base_expr, adjusted_ty, index_ty
3488 for &unsize in &[false, true] {
3489 let mut self_ty = adjusted_ty;
3491 // We only unsize arrays here.
3492 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3493 self_ty = self.tcx.mk_slice(element_ty);
3499 // If some lookup succeeds, write callee into table and extract index/element
3500 // type from the method signature.
3501 // If some lookup succeeded, install method in table
3502 let input_ty = self.next_ty_var(TypeVariableOrigin {
3503 kind: TypeVariableOriginKind::AutoDeref,
3504 span: base_expr.span,
3506 let method = self.try_overloaded_place_op(
3514 let result = method.map(|ok| {
3515 debug!("try_index_step: success, using overloaded indexing");
3516 let method = self.register_infer_ok_obligations(ok);
3518 let mut adjustments = autoderef.adjust_steps(self, needs);
3519 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3520 let mutbl = match r_mutbl {
3521 hir::Mutability::Not => AutoBorrowMutability::Not,
3522 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3523 // Indexing can be desugared to a method call,
3524 // so maybe we could use two-phase here.
3525 // See the documentation of AllowTwoPhase for why that's
3526 // not the case today.
3527 allow_two_phase_borrow: AllowTwoPhase::No,
3530 adjustments.push(Adjustment {
3531 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3534 .mk_ref(region, ty::TypeAndMut { mutbl: r_mutbl, ty: adjusted_ty }),
3538 adjustments.push(Adjustment {
3539 kind: Adjust::Pointer(PointerCast::Unsize),
3540 target: method.sig.inputs()[0],
3543 self.apply_adjustments(base_expr, adjustments);
3545 self.write_method_call(expr.hir_id, method);
3546 (input_ty, self.make_overloaded_place_return_type(method).ty)
3548 if result.is_some() {
3556 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3557 let (tr, name) = match (op, is_mut) {
3558 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3559 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3560 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3561 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3563 (tr, ast::Ident::with_dummy_span(name))
3566 fn try_overloaded_place_op(
3570 arg_tys: &[Ty<'tcx>],
3573 ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
3574 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})", span, base_ty, needs, op);
3576 // Try Mut first, if needed.
3577 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3578 let method = match (needs, mut_tr) {
3579 (Needs::MutPlace, Some(trait_did)) => {
3580 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3585 // Otherwise, fall back to the immutable version.
3586 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3587 let method = match (method, imm_tr) {
3588 (None, Some(trait_did)) => {
3589 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3591 (method, _) => method,
3597 fn check_method_argument_types(
3600 expr: &'tcx hir::Expr<'tcx>,
3601 method: Result<MethodCallee<'tcx>, ()>,
3602 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3603 tuple_arguments: TupleArgumentsFlag,
3604 expected: Expectation<'tcx>,
3606 let has_error = match method {
3607 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3611 let err_inputs = self.err_args(args_no_rcvr.len());
3613 let err_inputs = match tuple_arguments {
3614 DontTupleArguments => err_inputs,
3615 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3618 self.check_argument_types(
3628 return self.tcx.types.err;
3631 let method = method.unwrap();
3632 // HACK(eddyb) ignore self in the definition (see above).
3633 let expected_arg_tys = self.expected_inputs_for_expected_output(
3636 method.sig.output(),
3637 &method.sig.inputs()[1..],
3639 self.check_argument_types(
3642 &method.sig.inputs()[1..],
3643 &expected_arg_tys[..],
3645 method.sig.c_variadic,
3647 self.tcx.hir().span_if_local(method.def_id),
3652 fn self_type_matches_expected_vid(
3654 trait_ref: ty::PolyTraitRef<'tcx>,
3655 expected_vid: ty::TyVid,
3657 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3659 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3660 trait_ref, self_ty, expected_vid
3662 match self_ty.kind {
3663 ty::Infer(ty::TyVar(found_vid)) => {
3664 // FIXME: consider using `sub_root_var` here so we
3665 // can see through subtyping.
3666 let found_vid = self.root_var(found_vid);
3667 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3668 expected_vid == found_vid
3674 fn obligations_for_self_ty<'b>(
3677 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3680 // FIXME: consider using `sub_root_var` here so we
3681 // can see through subtyping.
3682 let ty_var_root = self.root_var(self_ty);
3684 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3687 self.fulfillment_cx.borrow().pending_obligations()
3692 .pending_obligations()
3694 .filter_map(move |obligation| match obligation.predicate {
3695 ty::Predicate::Projection(ref data) => {
3696 Some((data.to_poly_trait_ref(self.tcx), obligation))
3698 ty::Predicate::Trait(ref data) => Some((data.to_poly_trait_ref(), obligation)),
3699 ty::Predicate::Subtype(..) => None,
3700 ty::Predicate::RegionOutlives(..) => None,
3701 ty::Predicate::TypeOutlives(..) => None,
3702 ty::Predicate::WellFormed(..) => None,
3703 ty::Predicate::ObjectSafe(..) => None,
3704 ty::Predicate::ConstEvaluatable(..) => None,
3705 // N.B., this predicate is created by breaking down a
3706 // `ClosureType: FnFoo()` predicate, where
3707 // `ClosureType` represents some `Closure`. It can't
3708 // possibly be referring to the current closure,
3709 // because we haven't produced the `Closure` for
3710 // this closure yet; this is exactly why the other
3711 // code is looking for a self type of a unresolved
3712 // inference variable.
3713 ty::Predicate::ClosureKind(..) => None,
3715 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3718 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3719 self.obligations_for_self_ty(self_ty)
3720 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3723 /// Generic function that factors out common logic from function calls,
3724 /// method calls and overloaded operators.
3725 fn check_argument_types(
3728 expr: &'tcx hir::Expr<'tcx>,
3729 fn_inputs: &[Ty<'tcx>],
3730 expected_arg_tys: &[Ty<'tcx>],
3731 args: &'tcx [hir::Expr<'tcx>],
3733 tuple_arguments: TupleArgumentsFlag,
3734 def_span: Option<Span>,
3737 // Grab the argument types, supplying fresh type variables
3738 // if the wrong number of arguments were supplied
3739 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3741 // All the input types from the fn signature must outlive the call
3742 // so as to validate implied bounds.
3743 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3744 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3747 let expected_arg_count = fn_inputs.len();
3749 let param_count_error = |expected_count: usize,
3754 let mut err = tcx.sess.struct_span_err_with_code(
3757 "this function takes {}{} but {} {} supplied",
3758 if c_variadic { "at least " } else { "" },
3759 potentially_plural_count(expected_count, "parameter"),
3760 potentially_plural_count(arg_count, "parameter"),
3761 if arg_count == 1 { "was" } else { "were" }
3763 DiagnosticId::Error(error_code.to_owned()),
3766 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3767 err.span_label(def_s, "defined here");
3770 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3771 // remove closing `)` from the span
3772 let sugg_span = sugg_span.shrink_to_lo();
3773 err.span_suggestion(
3775 "expected the unit value `()`; create it with empty parentheses",
3777 Applicability::MachineApplicable,
3784 if c_variadic { "at least " } else { "" },
3785 potentially_plural_count(expected_count, "parameter")
3792 let mut expected_arg_tys = expected_arg_tys.to_vec();
3794 let formal_tys = if tuple_arguments == TupleArguments {
3795 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3796 match tuple_type.kind {
3797 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3798 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3799 expected_arg_tys = vec![];
3800 self.err_args(args.len())
3802 ty::Tuple(arg_types) => {
3803 expected_arg_tys = match expected_arg_tys.get(0) {
3804 Some(&ty) => match ty.kind {
3805 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3810 arg_types.iter().map(|k| k.expect_ty()).collect()
3817 "cannot use call notation; the first type parameter \
3818 for the function trait is neither a tuple nor unit"
3821 expected_arg_tys = vec![];
3822 self.err_args(args.len())
3825 } else if expected_arg_count == supplied_arg_count {
3827 } else if c_variadic {
3828 if supplied_arg_count >= expected_arg_count {
3831 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3832 expected_arg_tys = vec![];
3833 self.err_args(supplied_arg_count)
3836 // is the missing argument of type `()`?
3837 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3838 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3839 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3840 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3844 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3846 expected_arg_tys = vec![];
3847 self.err_args(supplied_arg_count)
3851 "check_argument_types: formal_tys={:?}",
3852 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
3855 // If there is no expectation, expect formal_tys.
3856 let expected_arg_tys =
3857 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
3859 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3861 // Check the arguments.
3862 // We do this in a pretty awful way: first we type-check any arguments
3863 // that are not closures, then we type-check the closures. This is so
3864 // that we have more information about the types of arguments when we
3865 // type-check the functions. This isn't really the right way to do this.
3866 for &check_closures in &[false, true] {
3867 debug!("check_closures={}", check_closures);
3869 // More awful hacks: before we check argument types, try to do
3870 // an "opportunistic" vtable resolution of any trait bounds on
3871 // the call. This helps coercions.
3873 self.select_obligations_where_possible(false, |errors| {
3874 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3875 self.point_at_arg_instead_of_call_if_possible(
3877 &final_arg_types[..],
3884 // For C-variadic functions, we don't have a declared type for all of
3885 // the arguments hence we only do our usual type checking with
3886 // the arguments who's types we do know.
3887 let t = if c_variadic {
3889 } else if tuple_arguments == TupleArguments {
3894 for (i, arg) in args.iter().take(t).enumerate() {
3895 // Warn only for the first loop (the "no closures" one).
3896 // Closure arguments themselves can't be diverging, but
3897 // a previous argument can, e.g., `foo(panic!(), || {})`.
3898 if !check_closures {
3899 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3902 let is_closure = match arg.kind {
3903 ExprKind::Closure(..) => true,
3907 if is_closure != check_closures {
3911 debug!("checking the argument");
3912 let formal_ty = formal_tys[i];
3914 // The special-cased logic below has three functions:
3915 // 1. Provide as good of an expected type as possible.
3916 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3918 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3920 // 2. Coerce to the most detailed type that could be coerced
3921 // to, which is `expected_ty` if `rvalue_hint` returns an
3922 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3923 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3924 // We're processing function arguments so we definitely want to use
3925 // two-phase borrows.
3926 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3927 final_arg_types.push((i, checked_ty, coerce_ty));
3929 // 3. Relate the expected type and the formal one,
3930 // if the expected type was used for the coercion.
3931 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3935 // We also need to make sure we at least write the ty of the other
3936 // arguments which we skipped above.
3938 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3939 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
3940 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3943 for arg in args.iter().skip(expected_arg_count) {
3944 let arg_ty = self.check_expr(&arg);
3946 // There are a few types which get autopromoted when passed via varargs
3947 // in C but we just error out instead and require explicit casts.
3948 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3950 ty::Float(ast::FloatTy::F32) => {
3951 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3953 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3954 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3956 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3957 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3960 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3961 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3962 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3970 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3971 vec![self.tcx.types.err; len]
3974 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
3975 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
3976 /// reference a type argument. The reason to walk also the checked type is that the coerced type
3977 /// can be not easily comparable with predicate type (because of coercion). If the types match
3978 /// for either checked or coerced type, and there's only *one* argument that does, we point at
3979 /// the corresponding argument's expression span instead of the `fn` call path span.
3980 fn point_at_arg_instead_of_call_if_possible(
3982 errors: &mut Vec<traits::FulfillmentError<'_>>,
3983 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
3985 args: &'tcx [hir::Expr<'tcx>],
3987 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3988 // the `?` operator.
3989 if call_sp.desugaring_kind().is_some() {
3993 for error in errors {
3994 // Only if the cause is somewhere inside the expression we want try to point at arg.
3995 // Otherwise, it means that the cause is somewhere else and we should not change
3996 // anything because we can break the correct span.
3997 if !call_sp.contains(error.obligation.cause.span) {
4001 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
4002 // Collect the argument position for all arguments that could have caused this
4003 // `FulfillmentError`.
4004 let mut referenced_in = final_arg_types
4006 .map(|(i, checked_ty, _)| (i, checked_ty))
4007 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
4008 .flat_map(|(i, ty)| {
4009 let ty = self.resolve_vars_if_possible(ty);
4010 // We walk the argument type because the argument's type could have
4011 // been `Option<T>`, but the `FulfillmentError` references `T`.
4013 .filter(|&ty| ty == predicate.skip_binder().self_ty())
4016 .collect::<Vec<_>>();
4018 // Both checked and coerced types could have matched, thus we need to remove
4020 referenced_in.dedup();
4022 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
4023 // We make sure that only *one* argument matches the obligation failure
4024 // and we assign the obligation's span to its expression's.
4025 error.obligation.cause.span = args[ref_in].span;
4026 error.points_at_arg_span = true;
4032 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
4033 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
4034 /// were caused by them. If they were, we point at the corresponding type argument's span
4035 /// instead of the `fn` call path span.
4036 fn point_at_type_arg_instead_of_call_if_possible(
4038 errors: &mut Vec<traits::FulfillmentError<'_>>,
4039 call_expr: &'tcx hir::Expr<'tcx>,
4041 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
4042 if let hir::ExprKind::Path(qpath) = &path.kind {
4043 if let hir::QPath::Resolved(_, path) = &qpath {
4044 for error in errors {
4045 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
4046 // If any of the type arguments in this path segment caused the
4047 // `FullfillmentError`, point at its span (#61860).
4051 .filter_map(|seg| seg.args.as_ref())
4052 .flat_map(|a| a.args.iter())
4054 if let hir::GenericArg::Type(hir_ty) = &arg {
4055 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4058 // Avoid ICE with associated types. As this is best
4059 // effort only, it's ok to ignore the case. It
4060 // would trigger in `is_send::<T::AssocType>();`
4061 // from `typeck-default-trait-impl-assoc-type.rs`.
4063 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4064 let ty = self.resolve_vars_if_possible(&ty);
4065 if ty == predicate.skip_binder().self_ty() {
4066 error.obligation.cause.span = hir_ty.span;
4078 // AST fragment checking
4079 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4083 ast::LitKind::Str(..) => tcx.mk_static_str(),
4084 ast::LitKind::ByteStr(ref v) => {
4085 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4087 ast::LitKind::Byte(_) => tcx.types.u8,
4088 ast::LitKind::Char(_) => tcx.types.char,
4089 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4090 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4091 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4092 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4093 ty::Int(_) | ty::Uint(_) => Some(ty),
4094 ty::Char => Some(tcx.types.u8),
4095 ty::RawPtr(..) => Some(tcx.types.usize),
4096 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4099 opt_ty.unwrap_or_else(|| self.next_int_var())
4101 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4102 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4103 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4104 ty::Float(_) => Some(ty),
4107 opt_ty.unwrap_or_else(|| self.next_float_var())
4109 ast::LitKind::Bool(_) => tcx.types.bool,
4110 ast::LitKind::Err(_) => tcx.types.err,
4114 // Determine the `Self` type, using fresh variables for all variables
4115 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4116 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4118 pub fn impl_self_ty(
4120 span: Span, // (potential) receiver for this impl
4122 ) -> TypeAndSubsts<'tcx> {
4123 let ity = self.tcx.type_of(did);
4124 debug!("impl_self_ty: ity={:?}", ity);
4126 let substs = self.fresh_substs_for_item(span, did);
4127 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4129 TypeAndSubsts { substs: substs, ty: substd_ty }
4132 /// Unifies the output type with the expected type early, for more coercions
4133 /// and forward type information on the input expressions.
4134 fn expected_inputs_for_expected_output(
4137 expected_ret: Expectation<'tcx>,
4138 formal_ret: Ty<'tcx>,
4139 formal_args: &[Ty<'tcx>],
4140 ) -> Vec<Ty<'tcx>> {
4141 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4142 let ret_ty = match expected_ret.only_has_type(self) {
4144 None => return Vec::new(),
4146 let expect_args = self
4147 .fudge_inference_if_ok(|| {
4148 // Attempt to apply a subtyping relationship between the formal
4149 // return type (likely containing type variables if the function
4150 // is polymorphic) and the expected return type.
4151 // No argument expectations are produced if unification fails.
4152 let origin = self.misc(call_span);
4153 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4155 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4156 // to identity so the resulting type is not constrained.
4159 // Process any obligations locally as much as
4160 // we can. We don't care if some things turn
4161 // out unconstrained or ambiguous, as we're
4162 // just trying to get hints here.
4163 self.save_and_restore_in_snapshot_flag(|_| {
4164 let mut fulfill = TraitEngine::new(self.tcx);
4165 for obligation in ok.obligations {
4166 fulfill.register_predicate_obligation(self, obligation);
4168 fulfill.select_where_possible(self)
4172 Err(_) => return Err(()),
4175 // Record all the argument types, with the substitutions
4176 // produced from the above subtyping unification.
4177 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4179 .unwrap_or_default();
4181 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4182 formal_args, formal_ret, expect_args, expected_ret
4187 pub fn check_struct_path(
4191 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4192 let path_span = match *qpath {
4193 QPath::Resolved(_, ref path) => path.span,
4194 QPath::TypeRelative(ref qself, _) => qself.span,
4196 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4197 let variant = match def {
4199 self.set_tainted_by_errors();
4202 Res::Def(DefKind::Variant, _) => match ty.kind {
4203 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4204 _ => bug!("unexpected type: {:?}", ty),
4206 Res::Def(DefKind::Struct, _)
4207 | Res::Def(DefKind::Union, _)
4208 | Res::Def(DefKind::TyAlias, _)
4209 | Res::Def(DefKind::AssocTy, _)
4210 | Res::SelfTy(..) => match ty.kind {
4211 ty::Adt(adt, substs) if !adt.is_enum() => {
4212 Some((adt.non_enum_variant(), adt.did, substs))
4216 _ => bug!("unexpected definition: {:?}", def),
4219 if let Some((variant, did, substs)) = variant {
4220 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4221 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4223 // Check bounds on type arguments used in the path.
4224 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4226 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4227 self.add_obligations_for_parameters(cause, &bounds);
4235 "expected struct, variant or union type, found {}",
4236 ty.sort_string(self.tcx)
4238 .span_label(path_span, "not a struct")
4244 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4245 // The newly resolved definition is written into `type_dependent_defs`.
4246 fn finish_resolving_struct_path(
4251 ) -> (Res, Ty<'tcx>) {
4253 QPath::Resolved(ref maybe_qself, ref path) => {
4254 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4255 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4258 QPath::TypeRelative(ref qself, ref segment) => {
4259 let ty = self.to_ty(qself);
4261 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4267 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4268 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4269 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4271 // Write back the new resolution.
4272 self.write_resolution(hir_id, result);
4274 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4279 /// Resolves an associated value path into a base type and associated constant, or method
4280 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4281 pub fn resolve_ty_and_res_ufcs<'b>(
4283 qpath: &'b QPath<'b>,
4286 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4287 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4288 let (ty, qself, item_segment) = match *qpath {
4289 QPath::Resolved(ref opt_qself, ref path) => {
4292 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4296 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4298 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4299 // Return directly on cache hit. This is useful to avoid doubly reporting
4300 // errors with default match binding modes. See #44614.
4302 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4303 return (def, Some(ty), slice::from_ref(&**item_segment));
4305 let item_name = item_segment.ident;
4306 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4307 let result = match error {
4308 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4309 _ => Err(ErrorReported),
4311 if item_name.name != kw::Invalid {
4312 self.report_method_error(
4316 SelfSource::QPath(qself),
4320 .map(|mut e| e.emit());
4325 // Write back the new resolution.
4326 self.write_resolution(hir_id, result);
4328 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4330 slice::from_ref(&**item_segment),
4334 pub fn check_decl_initializer(
4336 local: &'tcx hir::Local<'tcx>,
4337 init: &'tcx hir::Expr<'tcx>,
4339 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4340 // for #42640 (default match binding modes).
4343 let ref_bindings = local.pat.contains_explicit_ref_binding();
4345 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4346 if let Some(m) = ref_bindings {
4347 // Somewhat subtle: if we have a `ref` binding in the pattern,
4348 // we want to avoid introducing coercions for the RHS. This is
4349 // both because it helps preserve sanity and, in the case of
4350 // ref mut, for soundness (issue #23116). In particular, in
4351 // the latter case, we need to be clear that the type of the
4352 // referent for the reference that results is *equal to* the
4353 // type of the place it is referencing, and not some
4354 // supertype thereof.
4355 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4356 self.demand_eqtype(init.span, local_ty, init_ty);
4359 self.check_expr_coercable_to_type(init, local_ty)
4363 /// Type check a `let` statement.
4364 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4365 // Determine and write the type which we'll check the pattern against.
4366 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4367 self.write_ty(local.hir_id, ty);
4369 // Type check the initializer.
4370 if let Some(ref init) = local.init {
4371 let init_ty = self.check_decl_initializer(local, &init);
4372 self.overwrite_local_ty_if_err(local, ty, init_ty);
4375 // Does the expected pattern type originate from an expression and what is the span?
4376 let (origin_expr, ty_span) = match (local.ty, local.init) {
4377 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4378 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4379 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4382 // Type check the pattern. Override if necessary to avoid knock-on errors.
4383 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4384 let pat_ty = self.node_ty(local.pat.hir_id);
4385 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4388 fn overwrite_local_ty_if_err(
4390 local: &'tcx hir::Local<'tcx>,
4394 if ty.references_error() {
4395 // Override the types everywhere with `types.err` to avoid knock on errors.
4396 self.write_ty(local.hir_id, ty);
4397 self.write_ty(local.pat.hir_id, ty);
4398 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4399 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4400 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4404 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4405 err.span_suggestion_short(
4406 span.shrink_to_hi(),
4407 "consider using a semicolon here",
4409 Applicability::MachineApplicable,
4413 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4414 // Don't do all the complex logic below for `DeclItem`.
4416 hir::StmtKind::Item(..) => return,
4417 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4420 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4422 // Hide the outer diverging and `has_errors` flags.
4423 let old_diverges = self.diverges.get();
4424 let old_has_errors = self.has_errors.get();
4425 self.diverges.set(Diverges::Maybe);
4426 self.has_errors.set(false);
4429 hir::StmtKind::Local(ref l) => {
4430 self.check_decl_local(&l);
4433 hir::StmtKind::Item(_) => {}
4434 hir::StmtKind::Expr(ref expr) => {
4435 // Check with expected type of `()`.
4437 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4438 self.suggest_semicolon_at_end(expr.span, err);
4441 hir::StmtKind::Semi(ref expr) => {
4442 self.check_expr(&expr);
4446 // Combine the diverging and `has_error` flags.
4447 self.diverges.set(self.diverges.get() | old_diverges);
4448 self.has_errors.set(self.has_errors.get() | old_has_errors);
4451 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4452 let unit = self.tcx.mk_unit();
4453 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4455 // if the block produces a `!` value, that can always be
4456 // (effectively) coerced to unit.
4458 self.demand_suptype(blk.span, unit, ty);
4462 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4463 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4464 /// when given code like the following:
4466 /// if false { return 0i32; } else { 1u32 }
4467 /// // ^^^^ point at this instead of the whole `if` expression
4469 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4470 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4471 let arm_spans: Vec<Span> = arms
4474 self.in_progress_tables
4475 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4476 .and_then(|arm_ty| {
4477 if arm_ty.is_never() {
4480 Some(match &arm.body.kind {
4481 // Point at the tail expression when possible.
4482 hir::ExprKind::Block(block, _) => {
4483 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4491 if arm_spans.len() == 1 {
4492 return arm_spans[0];
4498 fn check_block_with_expected(
4500 blk: &'tcx hir::Block<'tcx>,
4501 expected: Expectation<'tcx>,
4504 let mut fcx_ps = self.ps.borrow_mut();
4505 let unsafety_state = fcx_ps.recurse(blk);
4506 replace(&mut *fcx_ps, unsafety_state)
4509 // In some cases, blocks have just one exit, but other blocks
4510 // can be targeted by multiple breaks. This can happen both
4511 // with labeled blocks as well as when we desugar
4512 // a `try { ... }` expression.
4516 // 'a: { if true { break 'a Err(()); } Ok(()) }
4518 // Here we would wind up with two coercions, one from
4519 // `Err(())` and the other from the tail expression
4520 // `Ok(())`. If the tail expression is omitted, that's a
4521 // "forced unit" -- unless the block diverges, in which
4522 // case we can ignore the tail expression (e.g., `'a: {
4523 // break 'a 22; }` would not force the type of the block
4525 let tail_expr = blk.expr.as_ref();
4526 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4527 let coerce = if blk.targeted_by_break {
4528 CoerceMany::new(coerce_to_ty)
4530 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4531 Some(e) => slice::from_ref(e),
4534 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4537 let prev_diverges = self.diverges.get();
4538 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4540 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4541 for s in blk.stmts {
4545 // check the tail expression **without** holding the
4546 // `enclosing_breakables` lock below.
4547 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4549 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4550 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4551 let coerce = ctxt.coerce.as_mut().unwrap();
4552 if let Some(tail_expr_ty) = tail_expr_ty {
4553 let tail_expr = tail_expr.unwrap();
4554 let span = self.get_expr_coercion_span(tail_expr);
4555 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4556 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4558 // Subtle: if there is no explicit tail expression,
4559 // that is typically equivalent to a tail expression
4560 // of `()` -- except if the block diverges. In that
4561 // case, there is no value supplied from the tail
4562 // expression (assuming there are no other breaks,
4563 // this implies that the type of the block will be
4566 // #41425 -- label the implicit `()` as being the
4567 // "found type" here, rather than the "expected type".
4568 if !self.diverges.get().is_always() {
4569 // #50009 -- Do not point at the entire fn block span, point at the return type
4570 // span, as it is the cause of the requirement, and
4571 // `consider_hint_about_removing_semicolon` will point at the last expression
4572 // if it were a relevant part of the error. This improves usability in editors
4573 // that highlight errors inline.
4574 let mut sp = blk.span;
4575 let mut fn_span = None;
4576 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4577 let ret_sp = decl.output.span();
4578 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4579 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4580 // output would otherwise be incorrect and even misleading. Make sure
4581 // the span we're aiming at correspond to a `fn` body.
4582 if block_sp == blk.span {
4584 fn_span = Some(ident.span);
4588 coerce.coerce_forced_unit(
4592 if let Some(expected_ty) = expected.only_has_type(self) {
4593 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4595 if let Some(fn_span) = fn_span {
4598 "implicitly returns `()` as its body has no tail or `return` \
4610 // If we can break from the block, then the block's exit is always reachable
4611 // (... as long as the entry is reachable) - regardless of the tail of the block.
4612 self.diverges.set(prev_diverges);
4615 let mut ty = ctxt.coerce.unwrap().complete(self);
4617 if self.has_errors.get() || ty.references_error() {
4618 ty = self.tcx.types.err
4621 self.write_ty(blk.hir_id, ty);
4623 *self.ps.borrow_mut() = prev;
4627 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4628 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4630 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4631 | Node::ImplItem(&hir::ImplItem {
4632 kind: hir::ImplItemKind::Method(_, body_id), ..
4634 let body = self.tcx.hir().body(body_id);
4635 if let ExprKind::Block(block, _) = &body.value.kind {
4636 return Some(block.span);
4644 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4645 fn get_parent_fn_decl(
4648 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident)> {
4649 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4650 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4653 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4654 fn get_node_fn_decl(
4657 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident, bool)> {
4659 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4660 // This is less than ideal, it will not suggest a return type span on any
4661 // method called `main`, regardless of whether it is actually the entry point,
4662 // but it will still present it as the reason for the expected type.
4663 Some((&sig.decl, ident, ident.name != sym::main))
4665 Node::TraitItem(&hir::TraitItem {
4667 kind: hir::TraitItemKind::Method(ref sig, ..),
4669 }) => Some((&sig.decl, ident, true)),
4670 Node::ImplItem(&hir::ImplItem {
4672 kind: hir::ImplItemKind::Method(ref sig, ..),
4674 }) => Some((&sig.decl, ident, false)),
4679 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4680 /// suggestion can be made, `None` otherwise.
4681 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4682 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4683 // `while` before reaching it, as block tail returns are not available in them.
4684 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4685 let parent = self.tcx.hir().get(blk_id);
4686 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4690 /// On implicit return expressions with mismatched types, provides the following suggestions:
4692 /// - Points out the method's return type as the reason for the expected type.
4693 /// - Possible missing semicolon.
4694 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4695 pub fn suggest_mismatched_types_on_tail(
4697 err: &mut DiagnosticBuilder<'_>,
4698 expr: &'tcx hir::Expr<'tcx>,
4704 let expr = expr.peel_drop_temps();
4705 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4706 let mut pointing_at_return_type = false;
4707 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4708 pointing_at_return_type =
4709 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4711 pointing_at_return_type
4714 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4715 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4717 /// fn foo(x: usize) -> usize { x }
4718 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4722 err: &mut DiagnosticBuilder<'_>,
4723 expr: &hir::Expr<'_>,
4727 let hir = self.tcx.hir();
4728 let (def_id, sig) = match found.kind {
4729 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4730 ty::Closure(def_id, substs) => {
4731 // We don't use `closure_sig` to account for malformed closures like
4732 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4733 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4736 match closure_sig_ty.kind {
4737 ty::FnPtr(sig) => sig,
4745 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4746 let sig = self.normalize_associated_types_in(expr.span, &sig);
4747 if self.can_coerce(sig.output(), expected) {
4748 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4749 (String::new(), Applicability::MachineApplicable)
4751 ("...".to_string(), Applicability::HasPlaceholders)
4753 let mut msg = "call this function";
4754 match hir.get_if_local(def_id) {
4755 Some(Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. }))
4756 | Some(Node::ImplItem(hir::ImplItem {
4757 kind: hir::ImplItemKind::Method(_, body_id),
4760 | Some(Node::TraitItem(hir::TraitItem {
4761 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4764 let body = hir.body(*body_id);
4768 .map(|param| match ¶m.pat.kind {
4769 hir::PatKind::Binding(_, _, ident, None)
4770 if ident.name != kw::SelfLower =>
4774 _ => "_".to_string(),
4776 .collect::<Vec<_>>()
4779 Some(Node::Expr(hir::Expr {
4780 kind: ExprKind::Closure(_, _, body_id, _, _),
4781 span: full_closure_span,
4784 if *full_closure_span == expr.span {
4787 msg = "call this closure";
4788 let body = hir.body(*body_id);
4792 .map(|param| match ¶m.pat.kind {
4793 hir::PatKind::Binding(_, _, ident, None)
4794 if ident.name != kw::SelfLower =>
4798 _ => "_".to_string(),
4800 .collect::<Vec<_>>()
4803 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4804 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4805 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4806 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4807 msg = "instantiate this tuple variant";
4809 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4810 msg = "instantiate this tuple struct";
4815 Some(Node::ForeignItem(hir::ForeignItem {
4816 kind: hir::ForeignItemKind::Fn(_, idents, _),
4822 if ident.name != kw::SelfLower {
4828 .collect::<Vec<_>>()
4831 Some(Node::TraitItem(hir::TraitItem {
4832 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4838 if ident.name != kw::SelfLower {
4844 .collect::<Vec<_>>()
4849 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4850 err.span_suggestion(
4852 &format!("use parentheses to {}", msg),
4853 format!("{}({})", code, sugg_call),
4862 pub fn suggest_ref_or_into(
4864 err: &mut DiagnosticBuilder<'_>,
4865 expr: &hir::Expr<'_>,
4869 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4870 err.span_suggestion(sp, msg, suggestion, Applicability::MachineApplicable);
4871 } else if let (ty::FnDef(def_id, ..), true) =
4872 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
4874 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4875 let sp = self.sess().source_map().def_span(sp);
4876 err.span_label(sp, &format!("{} defined here", found));
4878 } else if !self.check_for_cast(err, expr, found, expected) {
4879 let is_struct_pat_shorthand_field =
4880 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
4881 let methods = self.get_conversion_methods(expr.span, expected, found);
4882 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4883 let mut suggestions = iter::repeat(&expr_text)
4884 .zip(methods.iter())
4885 .filter_map(|(receiver, method)| {
4886 let method_call = format!(".{}()", method.ident);
4887 if receiver.ends_with(&method_call) {
4888 None // do not suggest code that is already there (#53348)
4890 let method_call_list = [".to_vec()", ".to_string()"];
4891 let sugg = if receiver.ends_with(".clone()")
4892 && method_call_list.contains(&method_call.as_str())
4894 let max_len = receiver.rfind(".").unwrap();
4895 format!("{}{}", &receiver[..max_len], method_call)
4897 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
4898 format!("({}){}", receiver, method_call)
4900 format!("{}{}", receiver, method_call)
4903 Some(if is_struct_pat_shorthand_field {
4904 format!("{}: {}", receiver, sugg)
4911 if suggestions.peek().is_some() {
4912 err.span_suggestions(
4914 "try using a conversion method",
4916 Applicability::MaybeIncorrect,
4923 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4924 /// in the heap by calling `Box::new()`.
4925 fn suggest_boxing_when_appropriate(
4927 err: &mut DiagnosticBuilder<'_>,
4928 expr: &hir::Expr<'_>,
4932 if self.tcx.hir().is_const_context(expr.hir_id) {
4933 // Do not suggest `Box::new` in const context.
4936 if !expected.is_box() || found.is_box() {
4939 let boxed_found = self.tcx.mk_box(found);
4940 if let (true, Ok(snippet)) = (
4941 self.can_coerce(boxed_found, expected),
4942 self.sess().source_map().span_to_snippet(expr.span),
4944 err.span_suggestion(
4946 "store this in the heap by calling `Box::new`",
4947 format!("Box::new({})", snippet),
4948 Applicability::MachineApplicable,
4951 "for more on the distinction between the stack and the \
4952 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4953 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4954 https://doc.rust-lang.org/std/boxed/index.html",
4959 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4963 /// bar_that_returns_u32()
4967 /// This routine checks if the return expression in a block would make sense on its own as a
4968 /// statement and the return type has been left as default or has been specified as `()`. If so,
4969 /// it suggests adding a semicolon.
4970 fn suggest_missing_semicolon(
4972 err: &mut DiagnosticBuilder<'_>,
4973 expression: &'tcx hir::Expr<'tcx>,
4977 if expected.is_unit() {
4978 // `BlockTailExpression` only relevant if the tail expr would be
4979 // useful on its own.
4980 match expression.kind {
4982 | ExprKind::MethodCall(..)
4983 | ExprKind::Loop(..)
4984 | ExprKind::Match(..)
4985 | ExprKind::Block(..) => {
4986 err.span_suggestion(
4987 cause_span.shrink_to_hi(),
4988 "try adding a semicolon",
4990 Applicability::MachineApplicable,
4998 /// A possible error is to forget to add a return type that is needed:
5002 /// bar_that_returns_u32()
5006 /// This routine checks if the return type is left as default, the method is not part of an
5007 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
5009 fn suggest_missing_return_type(
5011 err: &mut DiagnosticBuilder<'_>,
5012 fn_decl: &hir::FnDecl<'_>,
5017 // Only suggest changing the return type for methods that
5018 // haven't set a return type at all (and aren't `fn main()` or an impl).
5019 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
5020 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
5021 err.span_suggestion(
5023 "try adding a return type",
5024 format!("-> {} ", self.resolve_vars_with_obligations(found)),
5025 Applicability::MachineApplicable,
5029 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
5030 err.span_label(span, "possibly return type missing here?");
5033 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
5034 // `fn main()` must return `()`, do not suggest changing return type
5035 err.span_label(span, "expected `()` because of default return type");
5038 // expectation was caused by something else, not the default return
5039 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
5040 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
5041 // Only point to return type if the expected type is the return type, as if they
5042 // are not, the expectation must have been caused by something else.
5043 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
5045 let ty = AstConv::ast_ty_to_ty(self, ty);
5046 debug!("suggest_missing_return_type: return type {:?}", ty);
5047 debug!("suggest_missing_return_type: expected type {:?}", ty);
5048 if ty.kind == expected.kind {
5049 err.span_label(sp, format!("expected `{}` because of return type", expected));
5057 /// A possible error is to forget to add `.await` when using futures:
5060 /// async fn make_u32() -> u32 {
5064 /// fn take_u32(x: u32) {}
5066 /// async fn foo() {
5067 /// let x = make_u32();
5072 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5073 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5074 /// `.await` to the tail of the expression.
5075 fn suggest_missing_await(
5077 err: &mut DiagnosticBuilder<'_>,
5078 expr: &hir::Expr<'_>,
5082 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5083 // body isn't `async`.
5084 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5085 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5086 let body = self.tcx().hir().body(body_id);
5087 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5089 // Check for `Future` implementations by constructing a predicate to
5090 // prove: `<T as Future>::Output == U`
5091 let future_trait = self.tcx.lang_items().future_trait().unwrap();
5092 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
5094 ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5095 // `<T as Future>::Output`
5096 projection_ty: ty::ProjectionTy {
5098 substs: self.tcx.mk_substs_trait(
5100 self.fresh_substs_for_item(sp, item_def_id),
5107 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5108 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5109 if self.infcx.predicate_may_hold(&obligation) {
5110 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5111 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5112 err.span_suggestion(
5114 "consider using `.await` here",
5115 format!("{}.await", code),
5116 Applicability::MaybeIncorrect,
5119 debug!("suggest_missing_await: no snippet for {:?}", sp);
5122 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5128 /// A common error is to add an extra semicolon:
5131 /// fn foo() -> usize {
5136 /// This routine checks if the final statement in a block is an
5137 /// expression with an explicit semicolon whose type is compatible
5138 /// with `expected_ty`. If so, it suggests removing the semicolon.
5139 fn consider_hint_about_removing_semicolon(
5141 blk: &'tcx hir::Block<'tcx>,
5142 expected_ty: Ty<'tcx>,
5143 err: &mut DiagnosticBuilder<'_>,
5145 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5146 err.span_suggestion(
5148 "consider removing this semicolon",
5150 Applicability::MachineApplicable,
5155 fn could_remove_semicolon(
5157 blk: &'tcx hir::Block<'tcx>,
5158 expected_ty: Ty<'tcx>,
5160 // Be helpful when the user wrote `{... expr;}` and
5161 // taking the `;` off is enough to fix the error.
5162 let last_stmt = blk.stmts.last()?;
5163 let last_expr = match last_stmt.kind {
5164 hir::StmtKind::Semi(ref e) => e,
5167 let last_expr_ty = self.node_ty(last_expr.hir_id);
5168 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5171 let original_span = original_sp(last_stmt.span, blk.span);
5172 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5175 // Instantiates the given path, which must refer to an item with the given
5176 // number of type parameters and type.
5177 pub fn instantiate_value_path(
5179 segments: &[hir::PathSegment<'_>],
5180 self_ty: Option<Ty<'tcx>>,
5184 ) -> (Ty<'tcx>, Res) {
5186 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5187 segments, self_ty, res, hir_id,
5192 let path_segs = match res {
5193 Res::Local(_) | Res::SelfCtor(_) => vec![],
5194 Res::Def(kind, def_id) => {
5195 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5197 _ => bug!("instantiate_value_path on {:?}", res),
5200 let mut user_self_ty = None;
5201 let mut is_alias_variant_ctor = false;
5203 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5204 if let Some(self_ty) = self_ty {
5205 let adt_def = self_ty.ty_adt_def().unwrap();
5206 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5207 is_alias_variant_ctor = true;
5210 Res::Def(DefKind::Method, def_id) | Res::Def(DefKind::AssocConst, def_id) => {
5211 let container = tcx.associated_item(def_id).container;
5212 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5214 ty::TraitContainer(trait_did) => {
5215 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5217 ty::ImplContainer(impl_def_id) => {
5218 if segments.len() == 1 {
5219 // `<T>::assoc` will end up here, and so
5220 // can `T::assoc`. It this came from an
5221 // inherent impl, we need to record the
5222 // `T` for posterity (see `UserSelfTy` for
5224 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5225 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5233 // Now that we have categorized what space the parameters for each
5234 // segment belong to, let's sort out the parameters that the user
5235 // provided (if any) into their appropriate spaces. We'll also report
5236 // errors if type parameters are provided in an inappropriate place.
5238 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5239 let generics_has_err = AstConv::prohibit_generics(
5241 segments.iter().enumerate().filter_map(|(index, seg)| {
5242 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5250 if let Res::Local(hid) = res {
5251 let ty = self.local_ty(span, hid).decl_ty;
5252 let ty = self.normalize_associated_types_in(span, &ty);
5253 self.write_ty(hir_id, ty);
5257 if generics_has_err {
5258 // Don't try to infer type parameters when prohibited generic arguments were given.
5259 user_self_ty = None;
5262 // Now we have to compare the types that the user *actually*
5263 // provided against the types that were *expected*. If the user
5264 // did not provide any types, then we want to substitute inference
5265 // variables. If the user provided some types, we may still need
5266 // to add defaults. If the user provided *too many* types, that's
5269 let mut infer_args_for_err = FxHashSet::default();
5270 for &PathSeg(def_id, index) in &path_segs {
5271 let seg = &segments[index];
5272 let generics = tcx.generics_of(def_id);
5273 // Argument-position `impl Trait` is treated as a normal generic
5274 // parameter internally, but we don't allow users to specify the
5275 // parameter's value explicitly, so we have to do some error-
5277 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5278 tcx, span, &generics, &seg, false, // `is_method_call`
5280 if suppress_errors {
5281 infer_args_for_err.insert(index);
5282 self.set_tainted_by_errors(); // See issue #53251.
5286 let has_self = path_segs
5288 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5291 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5292 let ty = self.impl_self_ty(span, impl_def_id).ty;
5293 let adt_def = ty.ty_adt_def();
5296 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5297 let variant = adt_def.non_enum_variant();
5298 let ctor_def_id = variant.ctor_def_id.unwrap();
5300 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5305 let mut err = tcx.sess.struct_span_err(
5307 "the `Self` constructor can only be used with tuple or unit structs",
5309 if let Some(adt_def) = adt_def {
5310 match adt_def.adt_kind() {
5312 err.help("did you mean to use one of the enum's variants?");
5314 AdtKind::Struct | AdtKind::Union => {
5315 err.span_suggestion(
5317 "use curly brackets",
5318 String::from("Self { /* fields */ }"),
5319 Applicability::HasPlaceholders,
5326 return (tcx.types.err, res);
5332 let def_id = res.def_id();
5334 // The things we are substituting into the type should not contain
5335 // escaping late-bound regions, and nor should the base type scheme.
5336 let ty = tcx.type_of(def_id);
5338 let substs = self_ctor_substs.unwrap_or_else(|| {
5339 AstConv::create_substs_for_generic_args(
5345 // Provide the generic args, and whether types should be inferred.
5347 if let Some(&PathSeg(_, index)) =
5348 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5350 // If we've encountered an `impl Trait`-related error, we're just
5351 // going to infer the arguments for better error messages.
5352 if !infer_args_for_err.contains(&index) {
5353 // Check whether the user has provided generic arguments.
5354 if let Some(ref data) = segments[index].args {
5355 return (Some(data), segments[index].infer_args);
5358 return (None, segments[index].infer_args);
5363 // Provide substitutions for parameters for which (valid) arguments have been provided.
5364 |param, arg| match (¶m.kind, arg) {
5365 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5366 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5368 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5369 self.to_ty(ty).into()
5371 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5372 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5374 _ => unreachable!(),
5376 // Provide substitutions for parameters for which arguments are inferred.
5377 |substs, param, infer_args| {
5379 GenericParamDefKind::Lifetime => {
5380 self.re_infer(Some(param), span).unwrap().into()
5382 GenericParamDefKind::Type { has_default, .. } => {
5383 if !infer_args && has_default {
5384 // If we have a default, then we it doesn't matter that we're not
5385 // inferring the type arguments: we provide the default where any
5387 let default = tcx.type_of(param.def_id);
5390 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5394 // If no type arguments were provided, we have to infer them.
5395 // This case also occurs as a result of some malformed input, e.g.
5396 // a lifetime argument being given instead of a type parameter.
5397 // Using inference instead of `Error` gives better error messages.
5398 self.var_for_def(span, param)
5401 GenericParamDefKind::Const => {
5402 // FIXME(const_generics:defaults)
5403 // No const parameters were provided, we have to infer them.
5404 self.var_for_def(span, param)
5410 assert!(!substs.has_escaping_bound_vars());
5411 assert!(!ty.has_escaping_bound_vars());
5413 // First, store the "user substs" for later.
5414 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5416 self.add_required_obligations(span, def_id, &substs);
5418 // Substitute the values for the type parameters into the type of
5419 // the referenced item.
5420 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5422 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5423 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5424 // is inherent, there is no `Self` parameter; instead, the impl needs
5425 // type parameters, which we can infer by unifying the provided `Self`
5426 // with the substituted impl type.
5427 // This also occurs for an enum variant on a type alias.
5428 let ty = tcx.type_of(impl_def_id);
5430 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5431 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5432 Ok(ok) => self.register_infer_ok_obligations(ok),
5434 self.tcx.sess.delay_span_bug(span, &format!(
5435 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5443 self.check_rustc_args_require_const(def_id, hir_id, span);
5445 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5446 self.write_substs(hir_id, substs);
5448 (ty_substituted, res)
5451 /// Add all the obligations that are required, substituting and normalized appropriately.
5452 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5453 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5455 for (i, mut obligation) in traits::predicates_for_generics(
5456 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5463 // This makes the error point at the bound, but we want to point at the argument
5464 if let Some(span) = spans.get(i) {
5465 obligation.cause.code = traits::BindingObligation(def_id, *span);
5467 self.register_predicate(obligation);
5471 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5472 // We're only interested in functions tagged with
5473 // #[rustc_args_required_const], so ignore anything that's not.
5474 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5478 // If our calling expression is indeed the function itself, we're good!
5479 // If not, generate an error that this can only be called directly.
5480 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5481 if let ExprKind::Call(ref callee, ..) = expr.kind {
5482 if callee.hir_id == hir_id {
5488 self.tcx.sess.span_err(
5490 "this function can only be invoked \
5491 directly, not through a function pointer",
5495 /// Resolves `typ` by a single level if `typ` is a type variable.
5496 /// If no resolution is possible, then an error is reported.
5497 /// Numeric inference variables may be left unresolved.
5498 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5499 let ty = self.resolve_vars_with_obligations(ty);
5500 if !ty.is_ty_var() {
5503 if !self.is_tainted_by_errors() {
5504 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5505 .note("type must be known at this point")
5508 self.demand_suptype(sp, self.tcx.types.err, ty);
5513 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5516 ctxt: BreakableCtxt<'tcx>,
5518 ) -> (BreakableCtxt<'tcx>, R) {
5521 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5522 index = enclosing_breakables.stack.len();
5523 enclosing_breakables.by_id.insert(id, index);
5524 enclosing_breakables.stack.push(ctxt);
5528 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5529 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5530 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5531 enclosing_breakables.stack.pop().expect("missing breakable context")
5536 /// Instantiate a QueryResponse in a probe context, without a
5537 /// good ObligationCause.
5538 fn probe_instantiate_query_response(
5541 original_values: &OriginalQueryValues<'tcx>,
5542 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5543 ) -> InferResult<'tcx, Ty<'tcx>> {
5544 self.instantiate_query_response_and_region_obligations(
5545 &traits::ObligationCause::misc(span, self.body_id),
5552 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5553 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5554 let mut contained_in_place = false;
5556 while let hir::Node::Expr(parent_expr) =
5557 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5559 match &parent_expr.kind {
5560 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5561 if lhs.hir_id == expr_id {
5562 contained_in_place = true;
5568 expr_id = parent_expr.hir_id;
5575 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5576 let own_counts = generics.own_counts();
5578 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5579 own_counts.types, own_counts.consts, ty
5582 if own_counts.types == 0 {
5586 // Make a vector of booleans initially `false`; set to `true` when used.
5587 let mut types_used = vec![false; own_counts.types];
5589 for leaf_ty in ty.walk() {
5590 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5591 debug!("found use of ty param num {}", index);
5592 types_used[index as usize - own_counts.lifetimes] = true;
5593 } else if let ty::Error = leaf_ty.kind {
5594 // If there is already another error, do not emit
5595 // an error for not using a type parameter.
5596 assert!(tcx.sess.has_errors());
5601 let types = generics.params.iter().filter(|param| match param.kind {
5602 ty::GenericParamDefKind::Type { .. } => true,
5605 for (&used, param) in types_used.iter().zip(types) {
5607 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5608 let span = tcx.hir().span(id);
5609 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5610 .span_label(span, "unused type parameter")
5616 fn fatally_break_rust(sess: &Session) {
5617 let handler = sess.diagnostic();
5618 handler.span_bug_no_panic(
5620 "It looks like you're trying to break rust; would you like some ICE?",
5622 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5623 handler.note_without_error(
5624 "we would appreciate a joke overview: \
5625 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5627 handler.note_without_error(&format!(
5628 "rustc {} running on {}",
5629 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5630 crate::session::config::host_triple(),
5634 fn potentially_plural_count(count: usize, word: &str) -> String {
5635 format!("{} {}{}", count, word, pluralize!(count))