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 errors::{pluralize, Applicability, DiagnosticBuilder, DiagnosticId};
94 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
95 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
96 use rustc::infer::error_reporting::TypeAnnotationNeeded::E0282;
97 use rustc::infer::opaque_types::OpaqueTypeDecl;
98 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
99 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
100 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
101 use rustc::middle::region;
102 use rustc::mir::interpret::ConstValue;
103 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
104 use rustc::ty::adjustment::{
105 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast,
107 use rustc::ty::fold::{TypeFoldable, TypeFolder};
108 use rustc::ty::layout::VariantIdx;
109 use rustc::ty::query::Providers;
110 use rustc::ty::subst::{GenericArgKind, InternalSubsts, Subst, SubstsRef, UserSelfTy, UserSubsts};
111 use rustc::ty::util::{Discr, IntTypeExt, Representability};
113 self, AdtKind, CanonicalUserType, Const, GenericParamDefKind, RegionKind, ToPolyTraitRef,
114 ToPredicate, Ty, TyCtxt, UserType,
116 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
117 use rustc_hir as hir;
118 use rustc_hir::def::{CtorOf, DefKind, Res};
119 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LOCAL_CRATE};
120 use rustc_hir::itemlikevisit::ItemLikeVisitor;
121 use rustc_hir::{ExprKind, GenericArg, HirIdMap, ItemKind, Node, PatKind, QPath};
122 use rustc_index::vec::Idx;
123 use rustc_span::hygiene::DesugaringKind;
124 use rustc_span::source_map::{original_sp, DUMMY_SP};
125 use rustc_span::symbol::{kw, sym, Ident};
126 use rustc_span::{self, BytePos, MultiSpan, Span};
127 use rustc_target::spec::abi::Abi;
130 use syntax::feature_gate::feature_err;
131 use syntax::util::parser::ExprPrecedence;
133 use rustc_error_codes::*;
135 use std::cell::{Cell, Ref, RefCell, RefMut};
137 use std::collections::hash_map::Entry;
139 use std::mem::replace;
140 use std::ops::{self, Deref};
144 use crate::require_c_abi_if_c_variadic;
145 use crate::session::config::EntryFnType;
146 use crate::session::Session;
147 use crate::util::captures::Captures;
148 use crate::util::common::{indenter, ErrorReported};
149 use crate::TypeAndSubsts;
151 use self::autoderef::Autoderef;
152 use self::callee::DeferredCallResolution;
153 use self::coercion::{CoerceMany, DynamicCoerceMany};
154 use self::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl};
155 use self::method::{MethodCallee, SelfSource};
156 pub use self::Expectation::*;
157 use self::TupleArgumentsFlag::*;
159 /// The type of a local binding, including the revealed type for anon types.
160 #[derive(Copy, Clone, Debug)]
161 pub struct LocalTy<'tcx> {
163 revealed_ty: Ty<'tcx>,
166 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
167 #[derive(Copy, Clone)]
168 struct MaybeInProgressTables<'a, 'tcx> {
169 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
172 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
173 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
174 match self.maybe_tables {
175 Some(tables) => tables.borrow(),
176 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables"),
180 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
181 match self.maybe_tables {
182 Some(tables) => tables.borrow_mut(),
183 None => bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables"),
188 /// Closures defined within the function. For example:
191 /// bar(move|| { ... })
194 /// Here, the function `foo()` and the closure passed to
195 /// `bar()` will each have their own `FnCtxt`, but they will
196 /// share the inherited fields.
197 pub struct Inherited<'a, 'tcx> {
198 infcx: InferCtxt<'a, 'tcx>,
200 tables: MaybeInProgressTables<'a, 'tcx>,
202 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
204 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
206 // Some additional `Sized` obligations badly affect type inference.
207 // These obligations are added in a later stage of typeck.
208 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
210 // When we process a call like `c()` where `c` is a closure type,
211 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
212 // `FnOnce` closure. In that case, we defer full resolution of the
213 // call until upvar inference can kick in and make the
214 // decision. We keep these deferred resolutions grouped by the
215 // def-id of the closure, so that once we decide, we can easily go
216 // back and process them.
217 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
219 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
221 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
223 // Opaque types found in explicit return types and their
224 // associated fresh inference variable. Writeback resolves these
225 // variables to get the concrete type, which can be used to
226 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
227 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
229 /// A map from inference variables created from opaque
230 /// type instantiations (`ty::Infer`) to the actual opaque
231 /// type (`ty::Opaque`). Used during fallback to map unconstrained
232 /// opaque type inference variables to their corresponding
234 opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
236 /// Each type parameter has an implicit region bound that
237 /// indicates it must outlive at least the function body (the user
238 /// may specify stronger requirements). This field indicates the
239 /// region of the callee. If it is `None`, then the parameter
240 /// environment is for an item or something where the "callee" is
242 implicit_region_bound: Option<ty::Region<'tcx>>,
244 body_id: Option<hir::BodyId>,
247 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
248 type Target = InferCtxt<'a, 'tcx>;
249 fn deref(&self) -> &Self::Target {
254 /// When type-checking an expression, we propagate downward
255 /// whatever type hint we are able in the form of an `Expectation`.
256 #[derive(Copy, Clone, Debug)]
257 pub enum Expectation<'tcx> {
258 /// We know nothing about what type this expression should have.
261 /// This expression should have the type given (or some subtype).
262 ExpectHasType(Ty<'tcx>),
264 /// This expression will be cast to the `Ty`.
265 ExpectCastableToType(Ty<'tcx>),
267 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
268 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
269 ExpectRvalueLikeUnsized(Ty<'tcx>),
272 impl<'a, 'tcx> Expectation<'tcx> {
273 // Disregard "castable to" expectations because they
274 // can lead us astray. Consider for example `if cond
275 // {22} else {c} as u8` -- if we propagate the
276 // "castable to u8" constraint to 22, it will pick the
277 // type 22u8, which is overly constrained (c might not
278 // be a u8). In effect, the problem is that the
279 // "castable to" expectation is not the tightest thing
280 // we can say, so we want to drop it in this case.
281 // The tightest thing we can say is "must unify with
282 // else branch". Note that in the case of a "has type"
283 // constraint, this limitation does not hold.
285 // If the expected type is just a type variable, then don't use
286 // an expected type. Otherwise, we might write parts of the type
287 // when checking the 'then' block which are incompatible with the
289 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
291 ExpectHasType(ety) => {
292 let ety = fcx.shallow_resolve(ety);
293 if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
295 ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
300 /// Provides an expectation for an rvalue expression given an *optional*
301 /// hint, which is not required for type safety (the resulting type might
302 /// be checked higher up, as is the case with `&expr` and `box expr`), but
303 /// is useful in determining the concrete type.
305 /// The primary use case is where the expected type is a fat pointer,
306 /// like `&[isize]`. For example, consider the following statement:
308 /// let x: &[isize] = &[1, 2, 3];
310 /// In this case, the expected type for the `&[1, 2, 3]` expression is
311 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
312 /// expectation `ExpectHasType([isize])`, that would be too strong --
313 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
314 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
315 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
316 /// which still is useful, because it informs integer literals and the like.
317 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
318 /// for examples of where this comes up,.
319 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
320 match fcx.tcx.struct_tail_without_normalization(ty).kind {
321 ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
322 _ => ExpectHasType(ty),
326 // Resolves `expected` by a single level if it is a variable. If
327 // there is no expected type or resolution is not possible (e.g.,
328 // no constraints yet present), just returns `None`.
329 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
331 NoExpectation => NoExpectation,
332 ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
333 ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
334 ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
338 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
339 match self.resolve(fcx) {
340 NoExpectation => None,
341 ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
345 /// It sometimes happens that we want to turn an expectation into
346 /// a **hard constraint** (i.e., something that must be satisfied
347 /// for the program to type-check). `only_has_type` will return
348 /// such a constraint, if it exists.
349 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
350 match self.resolve(fcx) {
351 ExpectHasType(ty) => Some(ty),
352 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
356 /// Like `only_has_type`, but instead of returning `None` if no
357 /// hard constraint exists, creates a fresh type variable.
358 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
359 self.only_has_type(fcx).unwrap_or_else(|| {
360 fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
365 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
372 fn maybe_mut_place(m: hir::Mutability) -> Self {
374 hir::Mutability::Mut => Needs::MutPlace,
375 hir::Mutability::Not => Needs::None,
380 #[derive(Copy, Clone)]
381 pub struct UnsafetyState {
383 pub unsafety: hir::Unsafety,
384 pub unsafe_push_count: u32,
389 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
390 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
393 pub fn recurse(&mut self, blk: &hir::Block<'_>) -> UnsafetyState {
394 use hir::BlockCheckMode;
395 match self.unsafety {
396 // If this unsafe, then if the outer function was already marked as
397 // unsafe we shouldn't attribute the unsafe'ness to the block. This
398 // way the block can be warned about instead of ignoring this
399 // extraneous block (functions are never warned about).
400 hir::Unsafety::Unsafe if self.from_fn => *self,
403 let (unsafety, def, count) = match blk.rules {
404 BlockCheckMode::PushUnsafeBlock(..) => {
405 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap())
407 BlockCheckMode::PopUnsafeBlock(..) => {
408 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap())
410 BlockCheckMode::UnsafeBlock(..) => {
411 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count)
413 BlockCheckMode::DefaultBlock => (unsafety, self.def, self.unsafe_push_count),
415 UnsafetyState { def, unsafety, unsafe_push_count: count, from_fn: false }
421 #[derive(Debug, Copy, Clone)]
427 /// Tracks whether executing a node may exit normally (versus
428 /// return/break/panic, which "diverge", leaving dead code in their
429 /// wake). Tracked semi-automatically (through type variables marked
430 /// as diverging), with some manual adjustments for control-flow
431 /// primitives (approximating a CFG).
432 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
434 /// Potentially unknown, some cases converge,
435 /// others require a CFG to determine them.
438 /// Definitely known to diverge and therefore
439 /// not reach the next sibling or its parent.
441 /// The `Span` points to the expression
442 /// that caused us to diverge
443 /// (e.g. `return`, `break`, etc).
445 /// In some cases (e.g. a `match` expression
446 /// where all arms diverge), we may be
447 /// able to provide a more informative
448 /// message to the user.
449 /// If this is `None`, a default messsage
450 /// will be generated, which is suitable
452 custom_note: Option<&'static str>,
455 /// Same as `Always` but with a reachability
456 /// warning already emitted.
460 // Convenience impls for combining `Diverges`.
462 impl ops::BitAnd for Diverges {
464 fn bitand(self, other: Self) -> Self {
465 cmp::min(self, other)
469 impl ops::BitOr for Diverges {
471 fn bitor(self, other: Self) -> Self {
472 cmp::max(self, other)
476 impl ops::BitAndAssign for Diverges {
477 fn bitand_assign(&mut self, other: Self) {
478 *self = *self & other;
482 impl ops::BitOrAssign for Diverges {
483 fn bitor_assign(&mut self, other: Self) {
484 *self = *self | other;
489 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
490 fn always(span: Span) -> Diverges {
491 Diverges::Always { span, custom_note: None }
494 fn is_always(self) -> bool {
495 // Enum comparison ignores the
496 // contents of fields, so we just
497 // fill them in with garbage here.
498 self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
502 pub struct BreakableCtxt<'tcx> {
505 // this is `null` for loops where break with a value is illegal,
506 // such as `while`, `for`, and `while let`
507 coerce: Option<DynamicCoerceMany<'tcx>>,
510 pub struct EnclosingBreakables<'tcx> {
511 stack: Vec<BreakableCtxt<'tcx>>,
512 by_id: HirIdMap<usize>,
515 impl<'tcx> EnclosingBreakables<'tcx> {
516 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
517 self.opt_find_breakable(target_id).unwrap_or_else(|| {
518 bug!("could not find enclosing breakable with id {}", target_id);
522 fn opt_find_breakable(&mut self, target_id: hir::HirId) -> Option<&mut BreakableCtxt<'tcx>> {
523 match self.by_id.get(&target_id) {
524 Some(ix) => Some(&mut self.stack[*ix]),
530 pub struct FnCtxt<'a, 'tcx> {
533 /// The parameter environment used for proving trait obligations
534 /// in this function. This can change when we descend into
535 /// closures (as they bring new things into scope), hence it is
536 /// not part of `Inherited` (as of the time of this writing,
537 /// closures do not yet change the environment, but they will
539 param_env: ty::ParamEnv<'tcx>,
541 /// Number of errors that had been reported when we started
542 /// checking this function. On exit, if we find that *more* errors
543 /// have been reported, we will skip regionck and other work that
544 /// expects the types within the function to be consistent.
545 // FIXME(matthewjasper) This should not exist, and it's not correct
546 // if type checking is run in parallel.
547 err_count_on_creation: usize,
549 /// If `Some`, this stores coercion information for returned
550 /// expressions. If `None`, this is in a context where return is
551 /// inappropriate, such as a const expression.
553 /// This is a `RefCell<DynamicCoerceMany>`, which means that we
554 /// can track all the return expressions and then use them to
555 /// compute a useful coercion from the set, similar to a match
556 /// expression or other branching context. You can use methods
557 /// like `expected_ty` to access the declared return type (if
559 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
561 /// First span of a return site that we find. Used in error messages.
562 ret_coercion_span: RefCell<Option<Span>>,
564 yield_ty: Option<Ty<'tcx>>,
566 ps: RefCell<UnsafetyState>,
568 /// Whether the last checked node generates a divergence (e.g.,
569 /// `return` will set this to `Always`). In general, when entering
570 /// an expression or other node in the tree, the initial value
571 /// indicates whether prior parts of the containing expression may
572 /// have diverged. It is then typically set to `Maybe` (and the
573 /// old value remembered) for processing the subparts of the
574 /// current expression. As each subpart is processed, they may set
575 /// the flag to `Always`, etc. Finally, at the end, we take the
576 /// result and "union" it with the original value, so that when we
577 /// return the flag indicates if any subpart of the parent
578 /// expression (up to and including this part) has diverged. So,
579 /// if you read it after evaluating a subexpression `X`, the value
580 /// you get indicates whether any subexpression that was
581 /// evaluating up to and including `X` diverged.
583 /// We currently use this flag only for diagnostic purposes:
585 /// - To warn about unreachable code: if, after processing a
586 /// sub-expression but before we have applied the effects of the
587 /// current node, we see that the flag is set to `Always`, we
588 /// can issue a warning. This corresponds to something like
589 /// `foo(return)`; we warn on the `foo()` expression. (We then
590 /// update the flag to `WarnedAlways` to suppress duplicate
591 /// reports.) Similarly, if we traverse to a fresh statement (or
592 /// tail expression) from a `Always` setting, we will issue a
593 /// warning. This corresponds to something like `{return;
594 /// foo();}` or `{return; 22}`, where we would warn on the
597 /// An expression represents dead code if, after checking it,
598 /// the diverges flag is set to something other than `Maybe`.
599 diverges: Cell<Diverges>,
601 /// Whether any child nodes have any type errors.
602 has_errors: Cell<bool>,
604 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
606 inh: &'a Inherited<'a, 'tcx>,
609 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
610 type Target = Inherited<'a, 'tcx>;
611 fn deref(&self) -> &Self::Target {
616 /// Helper type of a temporary returned by `Inherited::build(...)`.
617 /// Necessary because we can't write the following bound:
618 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
619 pub struct InheritedBuilder<'tcx> {
620 infcx: infer::InferCtxtBuilder<'tcx>,
624 impl Inherited<'_, 'tcx> {
625 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
626 let hir_id_root = if def_id.is_local() {
627 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
628 DefId::local(hir_id.owner)
634 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
640 impl<'tcx> InheritedBuilder<'tcx> {
641 fn enter<F, R>(&mut self, f: F) -> R
643 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
645 let def_id = self.def_id;
646 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
650 impl Inherited<'a, 'tcx> {
651 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
653 let item_id = tcx.hir().as_local_hir_id(def_id);
654 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
655 let implicit_region_bound = body_id.map(|body_id| {
656 let body = tcx.hir().body(body_id);
657 tcx.mk_region(ty::ReScope(region::Scope {
658 id: body.value.hir_id.local_id,
659 data: region::ScopeData::CallSite,
664 tables: MaybeInProgressTables { maybe_tables: infcx.in_progress_tables },
666 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
667 locals: RefCell::new(Default::default()),
668 deferred_sized_obligations: RefCell::new(Vec::new()),
669 deferred_call_resolutions: RefCell::new(Default::default()),
670 deferred_cast_checks: RefCell::new(Vec::new()),
671 deferred_generator_interiors: RefCell::new(Vec::new()),
672 opaque_types: RefCell::new(Default::default()),
673 opaque_types_vars: RefCell::new(Default::default()),
674 implicit_region_bound,
679 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
680 debug!("register_predicate({:?})", obligation);
681 if obligation.has_escaping_bound_vars() {
682 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
684 self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
687 fn register_predicates<I>(&self, obligations: I)
689 I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
691 for obligation in obligations {
692 self.register_predicate(obligation);
696 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
697 self.register_predicates(infer_ok.obligations);
701 fn normalize_associated_types_in<T>(
705 param_env: ty::ParamEnv<'tcx>,
709 T: TypeFoldable<'tcx>,
711 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
712 self.register_infer_ok_obligations(ok)
716 struct CheckItemTypesVisitor<'tcx> {
720 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
721 fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
722 check_item_type(self.tcx, i);
724 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
725 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
728 pub fn check_wf_new(tcx: TyCtxt<'_>) {
729 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
730 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
733 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
734 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
737 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
738 debug_assert!(crate_num == LOCAL_CRATE);
739 tcx.par_body_owners(|body_owner_def_id| {
740 tcx.ensure().typeck_tables_of(body_owner_def_id);
744 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
745 wfcheck::check_item_well_formed(tcx, def_id);
748 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
749 wfcheck::check_trait_item(tcx, def_id);
752 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
753 wfcheck::check_impl_item(tcx, def_id);
756 pub fn provide(providers: &mut Providers<'_>) {
757 method::provide(providers);
758 *providers = Providers {
761 diagnostic_only_typeck_tables_of,
765 check_item_well_formed,
766 check_trait_item_well_formed,
767 check_impl_item_well_formed,
768 check_mod_item_types,
773 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
774 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
777 /// If this `DefId` is a "primary tables entry", returns
778 /// `Some((body_id, header, decl))` with information about
779 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
782 /// If this function returns `Some`, then `typeck_tables(def_id)` will
783 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
784 /// may not succeed. In some cases where this function returns `None`
785 /// (notably closures), `typeck_tables(def_id)` would wind up
786 /// redirecting to the owning function.
790 ) -> Option<(hir::BodyId, Option<&hir::Ty<'_>>, Option<&hir::FnHeader>, Option<&hir::FnDecl<'_>>)> {
791 match tcx.hir().get(id) {
792 Node::Item(item) => match item.kind {
793 hir::ItemKind::Const(ref ty, body) | hir::ItemKind::Static(ref ty, _, body) => {
794 Some((body, Some(ty), None, None))
796 hir::ItemKind::Fn(ref sig, .., body) => {
797 Some((body, None, Some(&sig.header), Some(&sig.decl)))
801 Node::TraitItem(item) => match item.kind {
802 hir::TraitItemKind::Const(ref ty, Some(body)) => Some((body, Some(ty), None, None)),
803 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) => {
804 Some((body, None, Some(&sig.header), Some(&sig.decl)))
808 Node::ImplItem(item) => match item.kind {
809 hir::ImplItemKind::Const(ref ty, body) => Some((body, Some(ty), None, None)),
810 hir::ImplItemKind::Method(ref sig, body) => {
811 Some((body, None, Some(&sig.header), Some(&sig.decl)))
815 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
820 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
821 // Closures' tables come from their outermost function,
822 // as they are part of the same "inference environment".
823 let outer_def_id = tcx.closure_base_def_id(def_id);
824 if outer_def_id != def_id {
825 return tcx.has_typeck_tables(outer_def_id);
828 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
829 primary_body_of(tcx, id).is_some()
832 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
833 &*tcx.typeck_tables_of(def_id).used_trait_imports
836 /// Inspects the substs of opaque types, replacing any inference variables
837 /// with proper generic parameter from the identity substs.
839 /// This is run after we normalize the function signature, to fix any inference
840 /// variables introduced by the projection of associated types. This ensures that
841 /// any opaque types used in the signature continue to refer to generic parameters,
842 /// allowing them to be considered for defining uses in the function body
844 /// For example, consider this code.
849 /// fn use_it(self) -> Self::MyItem
851 /// impl<T, I> MyTrait for T where T: Iterator<Item = I> {
852 /// type MyItem = impl Iterator<Item = I>;
853 /// fn use_it(self) -> Self::MyItem {
859 /// When we normalize the signature of `use_it` from the impl block,
860 /// we will normalize `Self::MyItem` to the opaque type `impl Iterator<Item = I>`
861 /// However, this projection result may contain inference variables, due
862 /// to the way that projection works. We didn't have any inference variables
863 /// in the signature to begin with - leaving them in will cause us to incorrectly
864 /// conclude that we don't have a defining use of `MyItem`. By mapping inference
865 /// variables back to the actual generic parameters, we will correctly see that
866 /// we have a defining use of `MyItem`
867 fn fixup_opaque_types<'tcx, T>(tcx: TyCtxt<'tcx>, val: &T) -> T
869 T: TypeFoldable<'tcx>,
871 struct FixupFolder<'tcx> {
875 impl<'tcx> TypeFolder<'tcx> for FixupFolder<'tcx> {
876 fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
880 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
882 ty::Opaque(def_id, substs) => {
883 debug!("fixup_opaque_types: found type {:?}", ty);
884 // Here, we replace any inference variables that occur within
885 // the substs of an opaque type. By definition, any type occuring
886 // in the substs has a corresponding generic parameter, which is what
887 // we replace it with.
888 // This replacement is only run on the function signature, so any
889 // inference variables that we come across must be the rust of projection
890 // (there's no other way for a user to get inference variables into
891 // a function signature).
892 if ty.needs_infer() {
893 let new_substs = InternalSubsts::for_item(self.tcx, def_id, |param, _| {
894 let old_param = substs[param.index as usize];
895 match old_param.unpack() {
896 GenericArgKind::Type(old_ty) => {
897 if let ty::Infer(_) = old_ty.kind {
898 // Replace inference type with a generic parameter
899 self.tcx.mk_param_from_def(param)
901 old_param.fold_with(self)
904 GenericArgKind::Const(old_const) => {
905 if let ty::ConstKind::Infer(_) = old_const.val {
906 // This should never happen - we currently do not support
907 // 'const projections', e.g.:
908 // `impl<T: SomeTrait> MyTrait for T where <T as SomeTrait>::MyConst == 25`
909 // which should be the only way for us to end up with a const inference
910 // variable after projection. If Rust ever gains support for this kind
911 // of projection, this should *probably* be changed to
912 // `self.tcx.mk_param_from_def(param)`
914 "Found infer const: `{:?}` in opaque type: {:?}",
919 old_param.fold_with(self)
922 GenericArgKind::Lifetime(old_region) => {
923 if let RegionKind::ReVar(_) = old_region {
924 self.tcx.mk_param_from_def(param)
926 old_param.fold_with(self)
931 let new_ty = self.tcx.mk_opaque(def_id, new_substs);
932 debug!("fixup_opaque_types: new type: {:?}", new_ty);
938 _ => ty.super_fold_with(self),
943 debug!("fixup_opaque_types({:?})", val);
944 val.fold_with(&mut FixupFolder { tcx })
947 fn typeck_tables_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &ty::TypeckTables<'tcx> {
948 let fallback = move || tcx.type_of(def_id);
949 typeck_tables_of_with_fallback(tcx, def_id, fallback)
952 /// Used only to get `TypeckTables` for type inference during error recovery.
953 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
954 fn diagnostic_only_typeck_tables_of<'tcx>(
957 ) -> &ty::TypeckTables<'tcx> {
958 assert!(def_id.is_local());
959 let fallback = move || {
960 let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id).unwrap());
961 tcx.sess.delay_span_bug(span, "diagnostic only typeck table used");
964 typeck_tables_of_with_fallback(tcx, def_id, fallback)
967 fn typeck_tables_of_with_fallback<'tcx>(
970 fallback: impl Fn() -> Ty<'tcx> + 'tcx,
971 ) -> &'tcx ty::TypeckTables<'tcx> {
972 // Closures' tables come from their outermost function,
973 // as they are part of the same "inference environment".
974 let outer_def_id = tcx.closure_base_def_id(def_id);
975 if outer_def_id != def_id {
976 return tcx.typeck_tables_of(outer_def_id);
979 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
980 let span = tcx.hir().span(id);
982 // Figure out what primary body this item has.
983 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
984 span_bug!(span, "can't type-check body of {:?}", def_id);
986 let body = tcx.hir().body(body_id);
988 let tables = Inherited::build(tcx, def_id).enter(|inh| {
989 let param_env = tcx.param_env(def_id);
990 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
991 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
992 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
993 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl, &[], None)
998 check_abi(tcx, span, fn_sig.abi());
1000 // Compute the fty from point of view of inside the fn.
1001 let fn_sig = tcx.liberate_late_bound_regions(def_id, &fn_sig);
1002 let fn_sig = inh.normalize_associated_types_in(
1009 let fn_sig = fixup_opaque_types(tcx, &fn_sig);
1011 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
1014 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
1015 let expected_type = body_ty
1016 .and_then(|ty| match ty.kind {
1017 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
1020 .unwrap_or_else(fallback);
1021 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
1022 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
1024 let revealed_ty = if tcx.features().impl_trait_in_bindings {
1025 fcx.instantiate_opaque_types_from_value(id, &expected_type, body.value.span)
1030 // Gather locals in statics (because of block expressions).
1031 GatherLocalsVisitor { fcx: &fcx, parent_id: id }.visit_body(body);
1033 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
1035 fcx.write_ty(id, revealed_ty);
1040 // All type checking constraints were added, try to fallback unsolved variables.
1041 fcx.select_obligations_where_possible(false, |_| {});
1042 let mut fallback_has_occurred = false;
1044 // We do fallback in two passes, to try to generate
1045 // better error messages.
1046 // The first time, we do *not* replace opaque types.
1047 for ty in &fcx.unsolved_variables() {
1048 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::NoOpaque);
1050 // We now see if we can make progress. This might
1051 // cause us to unify inference variables for opaque types,
1052 // since we may have unified some other type variables
1053 // during the first phase of fallback.
1054 // This means that we only replace inference variables with their underlying
1055 // opaque types as a last resort.
1057 // In code like this:
1060 // type MyType = impl Copy;
1061 // fn produce() -> MyType { true }
1062 // fn bad_produce() -> MyType { panic!() }
1065 // we want to unify the opaque inference variable in `bad_produce`
1066 // with the diverging fallback for `panic!` (e.g. `()` or `!`).
1067 // This will produce a nice error message about conflicting concrete
1068 // types for `MyType`.
1070 // If we had tried to fallback the opaque inference variable to `MyType`,
1071 // we will generate a confusing type-check error that does not explicitly
1072 // refer to opaque types.
1073 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1075 // We now run fallback again, but this time we allow it to replace
1076 // unconstrained opaque type variables, in addition to performing
1077 // other kinds of fallback.
1078 for ty in &fcx.unsolved_variables() {
1079 fallback_has_occurred |= fcx.fallback_if_possible(ty, FallbackMode::All);
1082 // See if we can make any more progress.
1083 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
1085 // Even though coercion casts provide type hints, we check casts after fallback for
1086 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
1089 // Closure and generator analysis may run after fallback
1090 // because they don't constrain other type variables.
1091 fcx.closure_analyze(body);
1092 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
1093 fcx.resolve_generator_interiors(def_id);
1095 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
1096 let ty = fcx.normalize_ty(span, ty);
1097 fcx.require_type_is_sized(ty, span, code);
1100 fcx.select_all_obligations_or_error();
1102 if fn_decl.is_some() {
1103 fcx.regionck_fn(id, body);
1105 fcx.regionck_expr(body);
1108 fcx.resolve_type_vars_in_body(body)
1111 // Consistency check our TypeckTables instance can hold all ItemLocalIds
1112 // it will need to hold.
1113 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
1118 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
1119 if !tcx.sess.target.target.is_abi_supported(abi) {
1124 "The ABI `{}` is not supported for the current target",
1131 struct GatherLocalsVisitor<'a, 'tcx> {
1132 fcx: &'a FnCtxt<'a, 'tcx>,
1133 parent_id: hir::HirId,
1136 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
1137 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
1140 // infer the variable's type
1141 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
1142 kind: TypeVariableOriginKind::TypeInference,
1148 .insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
1152 // take type that the user specified
1153 self.fcx.locals.borrow_mut().insert(nid, typ);
1160 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
1161 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
1162 NestedVisitorMap::None
1165 // Add explicitly-declared locals.
1166 fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
1167 let local_ty = match local.ty {
1169 let o_ty = self.fcx.to_ty(&ty);
1171 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1172 self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
1181 .canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
1183 "visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1184 ty.hir_id, o_ty, revealed_ty, c_ty
1186 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1188 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1192 self.assign(local.span, local.hir_id, local_ty);
1195 "local variable {:?} is assigned type {}",
1198 .ty_to_string(self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty)
1200 intravisit::walk_local(self, local);
1203 // Add pattern bindings.
1204 fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
1205 if let PatKind::Binding(_, _, ident, _) = p.kind {
1206 let var_ty = self.assign(p.span, p.hir_id, None);
1208 if !self.fcx.tcx.features().unsized_locals {
1209 self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
1213 "pattern binding {} is assigned to {} with type {:?}",
1216 .ty_to_string(self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1220 intravisit::walk_pat(self, p);
1223 // Don't descend into the bodies of nested closures
1226 _: intravisit::FnKind<'tcx>,
1227 _: &'tcx hir::FnDecl<'tcx>,
1235 /// When `check_fn` is invoked on a generator (i.e., a body that
1236 /// includes yield), it returns back some information about the yield
1238 struct GeneratorTypes<'tcx> {
1239 /// Type of value that is yielded.
1242 /// Types that are captured (see `GeneratorInterior` for more).
1245 /// Indicates if the generator is movable or static (immovable).
1246 movability: hir::Movability,
1249 /// Helper used for fns and closures. Does the grungy work of checking a function
1250 /// body and returns the function context used for that purpose, since in the case of a fn item
1251 /// there is still a bit more to do.
1254 /// * inherited: other fields inherited from the enclosing fn (if any)
1255 fn check_fn<'a, 'tcx>(
1256 inherited: &'a Inherited<'a, 'tcx>,
1257 param_env: ty::ParamEnv<'tcx>,
1258 fn_sig: ty::FnSig<'tcx>,
1259 decl: &'tcx hir::FnDecl<'tcx>,
1261 body: &'tcx hir::Body<'tcx>,
1262 can_be_generator: Option<hir::Movability>,
1263 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1264 let mut fn_sig = fn_sig.clone();
1266 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1268 // Create the function context. This is either derived from scratch or,
1269 // in the case of closures, based on the outer context.
1270 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1271 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1274 let sess = tcx.sess;
1275 let hir = tcx.hir();
1277 let declared_ret_ty = fn_sig.output();
1278 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1279 let revealed_ret_ty =
1280 fcx.instantiate_opaque_types_from_value(fn_id, &declared_ret_ty, decl.output.span());
1281 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1282 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1283 fn_sig = tcx.mk_fn_sig(
1284 fn_sig.inputs().iter().cloned(),
1291 let span = body.value.span;
1293 fn_maybe_err(tcx, span, fn_sig.abi);
1295 if body.generator_kind.is_some() && can_be_generator.is_some() {
1297 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span });
1298 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1299 fcx.yield_ty = Some(yield_ty);
1302 let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id));
1303 let outer_hir_id = hir.as_local_hir_id(outer_def_id).unwrap();
1304 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body);
1306 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1307 // (as it's created inside the body itself, not passed in from outside).
1308 let maybe_va_list = if fn_sig.c_variadic {
1309 let va_list_did = tcx.require_lang_item(
1310 lang_items::VaListTypeLangItem,
1311 Some(body.params.last().unwrap().span),
1313 let region = tcx.mk_region(ty::ReScope(region::Scope {
1314 id: body.value.hir_id.local_id,
1315 data: region::ScopeData::CallSite,
1318 Some(tcx.type_of(va_list_did).subst(tcx, &[region.into()]))
1323 // Add formal parameters.
1324 let inputs_hir = hir.fn_decl_by_hir_id(fn_id).map(|decl| &decl.inputs);
1325 let inputs_fn = fn_sig.inputs().iter().copied();
1326 for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() {
1327 // Check the pattern.
1328 fcx.check_pat_top(¶m.pat, param_ty, try { inputs_hir?.get(idx)?.span }, false);
1330 // Check that argument is Sized.
1331 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1332 // for simple cases like `fn foo(x: Trait)`,
1333 // where we would error once on the parameter as a whole, and once on the binding `x`.
1334 if param.pat.simple_ident().is_none() && !tcx.features().unsized_locals {
1335 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1338 fcx.write_ty(param.hir_id, param_ty);
1341 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1343 fcx.check_return_expr(&body.value);
1345 // We insert the deferred_generator_interiors entry after visiting the body.
1346 // This ensures that all nested generators appear before the entry of this generator.
1347 // resolve_generator_interiors relies on this property.
1348 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1350 .next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span });
1351 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1352 Some(GeneratorTypes {
1353 yield_ty: fcx.yield_ty.unwrap(),
1355 movability: can_be_generator.unwrap(),
1361 // Finalize the return check by taking the LUB of the return types
1362 // we saw and assigning it to the expected return type. This isn't
1363 // really expected to fail, since the coercions would have failed
1364 // earlier when trying to find a LUB.
1366 // However, the behavior around `!` is sort of complex. In the
1367 // event that the `actual_return_ty` comes back as `!`, that
1368 // indicates that the fn either does not return or "returns" only
1369 // values of type `!`. In this case, if there is an expected
1370 // return type that is *not* `!`, that should be ok. But if the
1371 // return type is being inferred, we want to "fallback" to `!`:
1373 // let x = move || panic!();
1375 // To allow for that, I am creating a type variable with diverging
1376 // fallback. This was deemed ever so slightly better than unifying
1377 // the return value with `!` because it allows for the caller to
1378 // make more assumptions about the return type (e.g., they could do
1380 // let y: Option<u32> = Some(x());
1382 // which would then cause this return type to become `u32`, not
1384 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1385 let mut actual_return_ty = coercion.complete(&fcx);
1386 if actual_return_ty.is_never() {
1387 actual_return_ty = fcx.next_diverging_ty_var(TypeVariableOrigin {
1388 kind: TypeVariableOriginKind::DivergingFn,
1392 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1394 // Check that the main return type implements the termination trait.
1395 if let Some(term_id) = tcx.lang_items().termination() {
1396 if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
1397 let main_id = hir.as_local_hir_id(def_id).unwrap();
1398 if main_id == fn_id {
1399 let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
1400 let trait_ref = ty::TraitRef::new(term_id, substs);
1401 let return_ty_span = decl.output.span();
1402 let cause = traits::ObligationCause::new(
1405 ObligationCauseCode::MainFunctionType,
1408 inherited.register_predicate(traits::Obligation::new(
1411 trait_ref.to_predicate(),
1417 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1418 if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
1419 if panic_impl_did == hir.local_def_id(fn_id) {
1420 if let Some(panic_info_did) = tcx.lang_items().panic_info() {
1421 if declared_ret_ty.kind != ty::Never {
1422 sess.span_err(decl.output.span(), "return type should be `!`");
1425 let inputs = fn_sig.inputs();
1426 let span = hir.span(fn_id);
1427 if inputs.len() == 1 {
1428 let arg_is_panic_info = match inputs[0].kind {
1429 ty::Ref(region, ty, mutbl) => match ty.kind {
1430 ty::Adt(ref adt, _) => {
1431 adt.did == panic_info_did
1432 && mutbl == hir::Mutability::Not
1433 && *region != RegionKind::ReStatic
1440 if !arg_is_panic_info {
1441 sess.span_err(decl.inputs[0].span, "argument should be `&PanicInfo`");
1444 if let Node::Item(item) = hir.get(fn_id) {
1445 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1446 if !generics.params.is_empty() {
1447 sess.span_err(span, "should have no type parameters");
1452 let span = sess.source_map().def_span(span);
1453 sess.span_err(span, "function should have one argument");
1456 sess.err("language item required, but not found: `panic_info`");
1461 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1462 if let Some(alloc_error_handler_did) = tcx.lang_items().oom() {
1463 if alloc_error_handler_did == hir.local_def_id(fn_id) {
1464 if let Some(alloc_layout_did) = tcx.lang_items().alloc_layout() {
1465 if declared_ret_ty.kind != ty::Never {
1466 sess.span_err(decl.output.span(), "return type should be `!`");
1469 let inputs = fn_sig.inputs();
1470 let span = hir.span(fn_id);
1471 if inputs.len() == 1 {
1472 let arg_is_alloc_layout = match inputs[0].kind {
1473 ty::Adt(ref adt, _) => adt.did == alloc_layout_did,
1477 if !arg_is_alloc_layout {
1478 sess.span_err(decl.inputs[0].span, "argument should be `Layout`");
1481 if let Node::Item(item) = hir.get(fn_id) {
1482 if let ItemKind::Fn(_, ref generics, _) = item.kind {
1483 if !generics.params.is_empty() {
1486 "`#[alloc_error_handler]` function should have no type \
1493 let span = sess.source_map().def_span(span);
1494 sess.span_err(span, "function should have one argument");
1497 sess.err("language item required, but not found: `alloc_layout`");
1505 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1506 let def_id = tcx.hir().local_def_id(id);
1507 let def = tcx.adt_def(def_id);
1508 def.destructor(tcx); // force the destructor to be evaluated
1509 check_representable(tcx, span, def_id);
1511 if def.repr.simd() {
1512 check_simd(tcx, span, def_id);
1515 check_transparent(tcx, span, def_id);
1516 check_packed(tcx, span, def_id);
1519 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1520 let def_id = tcx.hir().local_def_id(id);
1521 let def = tcx.adt_def(def_id);
1522 def.destructor(tcx); // force the destructor to be evaluated
1523 check_representable(tcx, span, def_id);
1524 check_transparent(tcx, span, def_id);
1525 check_union_fields(tcx, span, def_id);
1526 check_packed(tcx, span, def_id);
1529 /// When the `#![feature(untagged_unions)]` gate is active,
1530 /// check that the fields of the `union` does not contain fields that need dropping.
1531 fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: DefId) -> bool {
1532 let item_type = tcx.type_of(item_def_id);
1533 if let ty::Adt(def, substs) = item_type.kind {
1534 assert!(def.is_union());
1535 let fields = &def.non_enum_variant().fields;
1536 for field in fields {
1537 let field_ty = field.ty(tcx, substs);
1538 // We are currently checking the type this field came from, so it must be local.
1539 let field_span = tcx.hir().span_if_local(field.did).unwrap();
1540 let param_env = tcx.param_env(field.did);
1541 if field_ty.needs_drop(tcx, param_env) {
1546 "unions may not contain fields that need dropping"
1548 .span_note(field_span, "`std::mem::ManuallyDrop` can be used to wrap the type")
1554 span_bug!(span, "unions must be ty::Adt, but got {:?}", item_type.kind);
1559 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1560 /// projections that would result in "inheriting lifetimes".
1561 fn check_opaque<'tcx>(
1564 substs: SubstsRef<'tcx>,
1566 origin: &hir::OpaqueTyOrigin,
1568 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1569 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1572 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1573 /// in "inheriting lifetimes".
1574 fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: DefId, span: Span) {
1576 tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1578 "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1583 struct ProhibitOpaqueVisitor<'tcx> {
1584 opaque_identity_ty: Ty<'tcx>,
1585 generics: &'tcx ty::Generics,
1588 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1589 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1590 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1591 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1594 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1595 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1596 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1597 return *index < self.generics.parent_count as u32;
1600 r.super_visit_with(self)
1604 let prohibit_opaque = match item.kind {
1605 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. })
1606 | ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1607 let mut visitor = ProhibitOpaqueVisitor {
1608 opaque_identity_ty: tcx
1609 .mk_opaque(def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1610 generics: tcx.generics_of(def_id),
1612 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1614 tcx.predicates_of(def_id)
1617 .any(|(predicate, _)| predicate.visit_with(&mut visitor))
1622 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1623 if prohibit_opaque {
1624 let is_async = match item.kind {
1625 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1626 hir::OpaqueTyOrigin::AsyncFn => true,
1629 _ => unreachable!(),
1632 tcx.sess.span_err(span, &format!(
1633 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1635 if is_async { "async fn" } else { "impl Trait" },
1640 /// Checks that an opaque type does not contain cycles.
1641 fn check_opaque_for_cycles<'tcx>(
1644 substs: SubstsRef<'tcx>,
1646 origin: &hir::OpaqueTyOrigin,
1648 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1649 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1650 struct_span_err!(tcx.sess, span, E0733, "recursion in an `async fn` requires boxing",)
1651 .span_label(span, "recursive `async fn`")
1652 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1656 struct_span_err!(tcx.sess, span, E0720, "opaque type expands to a recursive type",);
1657 err.span_label(span, "expands to a recursive type");
1658 if let ty::Opaque(..) = partially_expanded_type.kind {
1659 err.note("type resolves to itself");
1661 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1668 // Forbid defining intrinsics in Rust code,
1669 // as they must always be defined by the compiler.
1670 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1671 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1672 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1676 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) {
1678 "check_item_type(it.hir_id={}, it.name={})",
1680 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1682 let _indenter = indenter();
1684 // Consts can play a role in type-checking, so they are included here.
1685 hir::ItemKind::Static(..) => {
1686 let def_id = tcx.hir().local_def_id(it.hir_id);
1687 tcx.typeck_tables_of(def_id);
1688 maybe_check_static_with_link_section(tcx, def_id, it.span);
1690 hir::ItemKind::Const(..) => {
1691 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1693 hir::ItemKind::Enum(ref enum_definition, _) => {
1694 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1696 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1697 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1698 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1699 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1700 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1701 check_impl_items_against_trait(
1708 let trait_def_id = impl_trait_ref.def_id;
1709 check_on_unimplemented(tcx, trait_def_id, it);
1712 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1713 let def_id = tcx.hir().local_def_id(it.hir_id);
1714 check_on_unimplemented(tcx, def_id, it);
1716 for item in items.iter() {
1717 let item = tcx.hir().trait_item(item.id);
1718 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1719 let abi = sig.header.abi;
1720 fn_maybe_err(tcx, item.ident.span, abi);
1724 hir::ItemKind::Struct(..) => {
1725 check_struct(tcx, it.hir_id, it.span);
1727 hir::ItemKind::Union(..) => {
1728 check_union(tcx, it.hir_id, it.span);
1730 hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => {
1731 let def_id = tcx.hir().local_def_id(it.hir_id);
1733 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1734 check_opaque(tcx, def_id, substs, it.span, &origin);
1736 hir::ItemKind::TyAlias(..) => {
1737 let def_id = tcx.hir().local_def_id(it.hir_id);
1738 let pty_ty = tcx.type_of(def_id);
1739 let generics = tcx.generics_of(def_id);
1740 check_bounds_are_used(tcx, &generics, pty_ty);
1742 hir::ItemKind::ForeignMod(ref m) => {
1743 check_abi(tcx, it.span, m.abi);
1745 if m.abi == Abi::RustIntrinsic {
1746 for item in m.items {
1747 intrinsic::check_intrinsic_type(tcx, item);
1749 } else if m.abi == Abi::PlatformIntrinsic {
1750 for item in m.items {
1751 intrinsic::check_platform_intrinsic_type(tcx, item);
1754 for item in m.items {
1755 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1756 let own_counts = generics.own_counts();
1757 if generics.params.len() - own_counts.lifetimes != 0 {
1758 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1759 (_, 0) => ("type", "types", Some("u32")),
1760 // We don't specify an example value, because we can't generate
1761 // a valid value for any type.
1762 (0, _) => ("const", "consts", None),
1763 _ => ("type or const", "types or consts", None),
1769 "foreign items may not have {} parameters",
1772 .span_label(item.span, &format!("can't have {} parameters", kinds))
1774 // FIXME: once we start storing spans for type arguments, turn this
1775 // into a suggestion.
1777 "replace the {} parameters with concrete {}{}",
1780 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1786 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1787 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1792 _ => { /* nothing to do */ }
1796 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1797 // Only restricted on wasm32 target for now
1798 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1802 // If `#[link_section]` is missing, then nothing to verify
1803 let attrs = tcx.codegen_fn_attrs(id);
1804 if attrs.link_section.is_none() {
1808 // For the wasm32 target statics with `#[link_section]` are placed into custom
1809 // sections of the final output file, but this isn't link custom sections of
1810 // other executable formats. Namely we can only embed a list of bytes,
1811 // nothing with pointers to anything else or relocations. If any relocation
1812 // show up, reject them here.
1813 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1814 // the consumer's responsibility to ensure all bytes that have been read
1815 // have defined values.
1816 if let Ok(static_) = tcx.const_eval_poly(id) {
1817 let alloc = if let ty::ConstKind::Value(ConstValue::ByRef { alloc, .. }) = static_.val {
1820 bug!("Matching on non-ByRef static")
1822 if alloc.relocations().len() != 0 {
1823 let msg = "statics with a custom `#[link_section]` must be a \
1824 simple list of bytes on the wasm target with no \
1825 extra levels of indirection such as references";
1826 tcx.sess.span_err(span, msg);
1831 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) {
1832 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1833 // an error would be reported if this fails.
1834 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1837 fn report_forbidden_specialization(
1839 impl_item: &hir::ImplItem<'_>,
1842 let mut err = struct_span_err!(
1846 "`{}` specializes an item from a parent `impl`, but \
1847 that item is not marked `default`",
1850 err.span_label(impl_item.span, format!("cannot specialize default item `{}`", impl_item.ident));
1852 match tcx.span_of_impl(parent_impl) {
1854 err.span_label(span, "parent `impl` is here");
1856 "to specialize, `{}` in the parent `impl` must be marked `default`",
1861 err.note(&format!("parent implementation is in crate `{}`", cname));
1868 fn check_specialization_validity<'tcx>(
1870 trait_def: &ty::TraitDef,
1871 trait_item: &ty::AssocItem,
1873 impl_item: &hir::ImplItem<'_>,
1875 let kind = match impl_item.kind {
1876 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1877 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1878 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1879 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1882 let mut ancestor_impls = trait_def
1883 .ancestors(tcx, impl_id)
1885 .filter_map(|parent| {
1886 if parent.is_from_trait() {
1889 Some((parent, parent.item(tcx, trait_item.ident, kind, trait_def.def_id)))
1894 if ancestor_impls.peek().is_none() {
1895 // No parent, nothing to specialize.
1899 let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1901 // Parent impl exists, and contains the parent item we're trying to specialize, but
1902 // doesn't mark it `default`.
1903 Some(parent_item) if tcx.impl_item_is_final(&parent_item) => {
1904 Some(Err(parent_impl.def_id()))
1907 // Parent impl contains item and makes it specializable.
1908 Some(_) => Some(Ok(())),
1910 // Parent impl doesn't mention the item. This means it's inherited from the
1911 // grandparent. In that case, if parent is a `default impl`, inherited items use the
1912 // "defaultness" from the grandparent, else they are final.
1914 if tcx.impl_is_default(parent_impl.def_id()) {
1917 Some(Err(parent_impl.def_id()))
1923 // If `opt_result` is `None`, we have only encoutered `default impl`s that don't contain the
1924 // item. This is allowed, the item isn't actually getting specialized here.
1925 let result = opt_result.unwrap_or(Ok(()));
1927 if let Err(parent_impl) = result {
1928 report_forbidden_specialization(tcx, impl_item, parent_impl);
1932 fn check_impl_items_against_trait<'tcx>(
1934 full_impl_span: Span,
1936 impl_trait_ref: ty::TraitRef<'tcx>,
1937 impl_item_refs: &[hir::ImplItemRef<'_>],
1939 let impl_span = tcx.sess.source_map().def_span(full_impl_span);
1941 // If the trait reference itself is erroneous (so the compilation is going
1942 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1943 // isn't populated for such impls.
1944 if impl_trait_ref.references_error() {
1948 // Locate trait definition and items
1949 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1950 let mut overridden_associated_type = None;
1952 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1954 // Check existing impl methods to see if they are both present in trait
1955 // and compatible with trait signature
1956 for impl_item in impl_items() {
1957 let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id));
1958 let ty_trait_item = tcx
1959 .associated_items(impl_trait_ref.def_id)
1961 Namespace::from(&impl_item.kind) == Namespace::from(ac.kind)
1962 && tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id)
1965 // Not compatible, but needed for the error message
1966 tcx.associated_items(impl_trait_ref.def_id)
1967 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1970 // Check that impl definition matches trait definition
1971 if let Some(ty_trait_item) = ty_trait_item {
1972 match impl_item.kind {
1973 hir::ImplItemKind::Const(..) => {
1974 // Find associated const definition.
1975 if ty_trait_item.kind == ty::AssocKind::Const {
1984 let mut err = struct_span_err!(
1988 "item `{}` is an associated const, \
1989 which doesn't match its trait `{}`",
1991 impl_trait_ref.print_only_trait_path()
1993 err.span_label(impl_item.span, "does not match trait");
1994 // We can only get the spans from local trait definition
1995 // Same for E0324 and E0325
1996 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1997 err.span_label(trait_span, "item in trait");
2002 hir::ImplItemKind::Method(..) => {
2003 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2004 if ty_trait_item.kind == ty::AssocKind::Method {
2005 compare_impl_method(
2014 let mut err = struct_span_err!(
2018 "item `{}` is an associated method, \
2019 which doesn't match its trait `{}`",
2021 impl_trait_ref.print_only_trait_path()
2023 err.span_label(impl_item.span, "does not match trait");
2024 if let Some(trait_span) = opt_trait_span {
2025 err.span_label(trait_span, "item in trait");
2030 hir::ImplItemKind::OpaqueTy(..) | hir::ImplItemKind::TyAlias(_) => {
2031 let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
2032 if ty_trait_item.kind == ty::AssocKind::Type {
2033 if ty_trait_item.defaultness.has_value() {
2034 overridden_associated_type = Some(impl_item);
2045 let mut err = struct_span_err!(
2049 "item `{}` is an associated type, \
2050 which doesn't match its trait `{}`",
2052 impl_trait_ref.print_only_trait_path()
2054 err.span_label(impl_item.span, "does not match trait");
2055 if let Some(trait_span) = opt_trait_span {
2056 err.span_label(trait_span, "item in trait");
2063 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
2067 // Check for missing items from trait
2068 let mut missing_items = Vec::new();
2069 let mut invalidated_items = Vec::new();
2070 let associated_type_overridden = overridden_associated_type.is_some();
2071 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
2072 let is_implemented = trait_def
2073 .ancestors(tcx, impl_id)
2074 .leaf_def(tcx, trait_item.ident, trait_item.kind)
2075 .map(|node_item| !node_item.node.is_from_trait())
2078 if !is_implemented && !tcx.impl_is_default(impl_id) {
2079 if !trait_item.defaultness.has_value() {
2080 missing_items.push(trait_item);
2081 } else if associated_type_overridden {
2082 invalidated_items.push(trait_item.ident);
2087 if !missing_items.is_empty() {
2088 missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
2091 if !invalidated_items.is_empty() {
2092 let invalidator = overridden_associated_type.unwrap();
2097 "the following trait items need to be reimplemented as `{}` was overridden: `{}`",
2099 invalidated_items.iter().map(|name| name.to_string()).collect::<Vec<_>>().join("`, `")
2104 fn missing_items_err(
2107 missing_items: &[ty::AssocItem],
2108 full_impl_span: Span,
2110 let missing_items_msg = missing_items
2112 .map(|trait_item| trait_item.ident.to_string())
2113 .collect::<Vec<_>>()
2116 let mut err = struct_span_err!(
2120 "not all trait items implemented, missing: `{}`",
2123 err.span_label(impl_span, format!("missing `{}` in implementation", missing_items_msg));
2125 // `Span` before impl block closing brace.
2126 let hi = full_impl_span.hi() - BytePos(1);
2127 // Point at the place right before the closing brace of the relevant `impl` to suggest
2128 // adding the associated item at the end of its body.
2129 let sugg_sp = full_impl_span.with_lo(hi).with_hi(hi);
2130 // Obtain the level of indentation ending in `sugg_sp`.
2131 let indentation = tcx.sess.source_map().span_to_margin(sugg_sp).unwrap_or(0);
2132 // Make the whitespace that will make the suggestion have the right indentation.
2133 let padding: String = (0..indentation).map(|_| " ").collect();
2135 for trait_item in missing_items {
2136 let snippet = suggestion_signature(&trait_item, tcx);
2137 let code = format!("{}{}\n{}", padding, snippet, padding);
2138 let msg = format!("implement the missing item: `{}`", snippet);
2139 let appl = Applicability::HasPlaceholders;
2140 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
2141 err.span_label(span, format!("`{}` from trait", trait_item.ident));
2142 err.tool_only_span_suggestion(sugg_sp, &msg, code, appl);
2144 err.span_suggestion_hidden(sugg_sp, &msg, code, appl);
2150 /// Return placeholder code for the given function.
2151 fn fn_sig_suggestion(sig: &ty::FnSig<'_>, ident: Ident) -> String {
2156 Some(match ty.kind {
2157 ty::Param(param) if param.name == kw::SelfUpper => "self".to_string(),
2158 ty::Ref(reg, ref_ty, mutability) => {
2159 let reg = match &format!("{}", reg)[..] {
2160 "'_" | "" => String::new(),
2161 reg => format!("{} ", reg),
2164 ty::Param(param) if param.name == kw::SelfUpper => {
2165 format!("&{}{}self", reg, mutability.prefix_str())
2167 _ => format!("_: {:?}", ty),
2170 _ => format!("_: {:?}", ty),
2173 .chain(std::iter::once(if sig.c_variadic { Some("...".to_string()) } else { None }))
2174 .filter_map(|arg| arg)
2175 .collect::<Vec<String>>()
2177 let output = sig.output();
2178 let output = if !output.is_unit() { format!(" -> {:?}", output) } else { String::new() };
2180 let unsafety = sig.unsafety.prefix_str();
2181 // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
2182 // not be present in the `fn` definition, not will we account for renamed
2183 // lifetimes between the `impl` and the `trait`, but this should be good enough to
2184 // fill in a significant portion of the missing code, and other subsequent
2185 // suggestions can help the user fix the code.
2186 format!("{}fn {}({}){} {{ unimplemented!() }}", unsafety, ident, args, output)
2189 /// Return placeholder code for the given associated item.
2190 /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
2191 /// structured suggestion.
2192 fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String {
2194 ty::AssocKind::Method => {
2195 // We skip the binder here because the binder would deanonymize all
2196 // late-bound regions, and we don't want method signatures to show up
2197 // `as for<'r> fn(&'r MyType)`. Pretty-printing handles late-bound
2198 // regions just fine, showing `fn(&MyType)`.
2199 fn_sig_suggestion(tcx.fn_sig(assoc.def_id).skip_binder(), assoc.ident)
2201 ty::AssocKind::Type => format!("type {} = Type;", assoc.ident),
2202 // FIXME(type_alias_impl_trait): we should print bounds here too.
2203 ty::AssocKind::OpaqueTy => format!("type {} = Type;", assoc.ident),
2204 ty::AssocKind::Const => {
2205 let ty = tcx.type_of(assoc.def_id);
2206 let val = expr::ty_kind_suggestion(ty).unwrap_or("value");
2207 format!("const {}: {:?} = {};", assoc.ident, ty, val)
2212 /// Checks whether a type can be represented in memory. In particular, it
2213 /// identifies types that contain themselves without indirection through a
2214 /// pointer, which would mean their size is unbounded.
2215 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
2216 let rty = tcx.type_of(item_def_id);
2218 // Check that it is possible to represent this type. This call identifies
2219 // (1) types that contain themselves and (2) types that contain a different
2220 // recursive type. It is only necessary to throw an error on those that
2221 // contain themselves. For case 2, there must be an inner type that will be
2222 // caught by case 1.
2223 match rty.is_representable(tcx, sp) {
2224 Representability::SelfRecursive(spans) => {
2225 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
2227 err.span_label(span, "recursive without indirection");
2232 Representability::Representable | Representability::ContainsRecursive => (),
2237 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2238 let t = tcx.type_of(def_id);
2239 if let ty::Adt(def, substs) = t.kind {
2240 if def.is_struct() {
2241 let fields = &def.non_enum_variant().fields;
2242 if fields.is_empty() {
2243 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
2246 let e = fields[0].ty(tcx, substs);
2247 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
2248 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
2249 .span_label(sp, "SIMD elements must have the same type")
2254 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
2255 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
2261 "SIMD vector element type should be machine type"
2270 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2271 let repr = tcx.adt_def(def_id).repr;
2273 for attr in tcx.get_attrs(def_id).iter() {
2274 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
2275 if let attr::ReprPacked(pack) = r {
2276 if let Some(repr_pack) = repr.pack {
2277 if pack as u64 != repr_pack.bytes() {
2282 "type has conflicting packed representation hints"
2290 if repr.align.is_some() {
2295 "type has conflicting packed and align representation hints"
2298 } else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
2303 "packed type cannot transitively contain a `[repr(align)]` type"
2310 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
2311 let t = tcx.type_of(def_id);
2312 if stack.contains(&def_id) {
2313 debug!("check_packed_inner: {:?} is recursive", t);
2316 if let ty::Adt(def, substs) = t.kind {
2317 if def.is_struct() || def.is_union() {
2318 if tcx.adt_def(def.did).repr.align.is_some() {
2321 // push struct def_id before checking fields
2323 for field in &def.non_enum_variant().fields {
2324 let f = field.ty(tcx, substs);
2325 if let ty::Adt(def, _) = f.kind {
2326 if check_packed_inner(tcx, def.did, stack) {
2331 // only need to pop if not early out
2338 /// Emit an error when encountering more or less than one variant in a transparent enum.
2339 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
2340 let variant_spans: Vec<_> = adt
2343 .map(|variant| tcx.hir().span_if_local(variant.def_id).unwrap())
2345 let msg = format!("needs exactly one variant, but has {}", adt.variants.len(),);
2346 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2347 err.span_label(sp, &msg);
2348 if let [start @ .., end] = &*variant_spans {
2349 for variant_span in start {
2350 err.span_label(*variant_span, "");
2352 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2357 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2359 fn bad_non_zero_sized_fields<'tcx>(
2361 adt: &'tcx ty::AdtDef,
2363 field_spans: impl Iterator<Item = Span>,
2366 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2367 let mut err = struct_span_err!(
2371 "{}transparent {} {}",
2372 if adt.is_enum() { "the variant of a " } else { "" },
2376 err.span_label(sp, &msg);
2377 for sp in field_spans {
2378 err.span_label(sp, "this field is non-zero-sized");
2383 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2384 let adt = tcx.adt_def(def_id);
2385 if !adt.repr.transparent() {
2388 let sp = tcx.sess.source_map().def_span(sp);
2390 if adt.is_enum() && !tcx.features().transparent_enums {
2392 &tcx.sess.parse_sess,
2393 sym::transparent_enums,
2395 "transparent enums are unstable",
2400 if adt.is_union() && !tcx.features().transparent_unions {
2402 &tcx.sess.parse_sess,
2403 sym::transparent_unions,
2405 "transparent unions are unstable",
2410 if adt.variants.len() != 1 {
2411 bad_variant_count(tcx, adt, sp, def_id);
2412 if adt.variants.is_empty() {
2413 // Don't bother checking the fields. No variants (and thus no fields) exist.
2418 // For each field, figure out if it's known to be a ZST and align(1)
2419 let field_infos = adt.all_fields().map(|field| {
2420 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2421 let param_env = tcx.param_env(field.did);
2422 let layout = tcx.layout_of(param_env.and(ty));
2423 // We are currently checking the type this field came from, so it must be local
2424 let span = tcx.hir().span_if_local(field.did).unwrap();
2425 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2426 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2430 let non_zst_fields =
2431 field_infos.clone().filter_map(|(span, zst, _align1)| if !zst { Some(span) } else { None });
2432 let non_zst_count = non_zst_fields.clone().count();
2433 if non_zst_count != 1 {
2434 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2436 for (span, zst, align1) in field_infos {
2442 "zero-sized field in transparent {} has alignment larger than 1",
2445 .span_label(span, "has alignment larger than 1")
2451 #[allow(trivial_numeric_casts)]
2452 pub fn check_enum<'tcx>(
2455 vs: &'tcx [hir::Variant<'tcx>],
2458 let def_id = tcx.hir().local_def_id(id);
2459 let def = tcx.adt_def(def_id);
2460 def.destructor(tcx); // force the destructor to be evaluated
2463 let attributes = tcx.get_attrs(def_id);
2464 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2469 "unsupported representation for zero-variant enum"
2471 .span_label(sp, "zero-variant enum")
2476 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2477 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2478 if !tcx.features().repr128 {
2480 &tcx.sess.parse_sess,
2483 "repr with 128-bit type is unstable",
2490 if let Some(ref e) = v.disr_expr {
2491 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2495 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2496 let is_unit = |var: &hir::Variant<'_>| match var.data {
2497 hir::VariantData::Unit(..) => true,
2501 let has_disr = |var: &hir::Variant<'_>| var.disr_expr.is_some();
2502 let has_non_units = vs.iter().any(|var| !is_unit(var));
2503 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2504 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2506 if disr_non_unit || (disr_units && has_non_units) {
2508 struct_span_err!(tcx.sess, sp, E0732, "`#[repr(inttype)]` must be specified");
2513 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2514 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2515 // Check for duplicate discriminant values
2516 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2517 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2518 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2519 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2520 let i_span = match variant_i.disr_expr {
2521 Some(ref expr) => tcx.hir().span(expr.hir_id),
2522 None => tcx.hir().span(variant_i_hir_id),
2524 let span = match v.disr_expr {
2525 Some(ref expr) => tcx.hir().span(expr.hir_id),
2532 "discriminant value `{}` already exists",
2535 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2536 .span_label(span, format!("enum already has `{}`", disr_vals[i]))
2539 disr_vals.push(discr);
2542 check_representable(tcx, sp, def_id);
2543 check_transparent(tcx, sp, def_id);
2546 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath<'_>) {
2551 "expected unit struct, unit variant or constant, found {} `{}`",
2553 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false))
2557 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2558 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2562 fn item_def_id(&self) -> Option<DefId> {
2566 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> {
2568 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2569 let item_id = tcx.hir().ty_param_owner(hir_id);
2570 let item_def_id = tcx.hir().local_def_id(item_id);
2571 let generics = tcx.generics_of(item_def_id);
2572 let index = generics.param_def_id_to_index[&def_id];
2573 ty::GenericPredicates {
2575 predicates: tcx.arena.alloc_from_iter(self.param_env.caller_bounds.iter().filter_map(
2576 |&predicate| match predicate {
2577 ty::Predicate::Trait(ref data)
2578 if data.skip_binder().self_ty().is_param(index) =>
2580 // HACK(eddyb) should get the original `Span`.
2581 let span = tcx.def_span(def_id);
2582 Some((predicate, span))
2590 fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
2592 Some(def) => infer::EarlyBoundRegion(span, def.name),
2593 None => infer::MiscVariable(span),
2595 Some(self.next_region_var(v))
2598 fn allow_ty_infer(&self) -> bool {
2602 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2603 if let Some(param) = param {
2604 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2609 self.next_ty_var(TypeVariableOrigin {
2610 kind: TypeVariableOriginKind::TypeInference,
2619 param: Option<&ty::GenericParamDef>,
2621 ) -> &'tcx Const<'tcx> {
2622 if let Some(param) = param {
2623 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2628 self.next_const_var(
2630 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
2635 fn projected_ty_from_poly_trait_ref(
2639 item_segment: &hir::PathSegment<'_>,
2640 poly_trait_ref: ty::PolyTraitRef<'tcx>,
2642 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2644 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2648 let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
2657 self.tcx().mk_projection(item_def_id, item_substs)
2660 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2661 if ty.has_escaping_bound_vars() {
2662 ty // FIXME: normalization and escaping regions
2664 self.normalize_associated_types_in(span, &ty)
2668 fn set_tainted_by_errors(&self) {
2669 self.infcx.set_tainted_by_errors()
2672 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2673 self.write_ty(hir_id, ty)
2677 /// Controls whether the arguments are tupled. This is used for the call
2680 /// Tupling means that all call-side arguments are packed into a tuple and
2681 /// passed as a single parameter. For example, if tupling is enabled, this
2684 /// fn f(x: (isize, isize))
2686 /// Can be called as:
2693 #[derive(Clone, Eq, PartialEq)]
2694 enum TupleArgumentsFlag {
2699 /// Controls how we perform fallback for unconstrained
2702 /// Do not fallback type variables to opaque types.
2704 /// Perform all possible kinds of fallback, including
2705 /// turning type variables to opaque types.
2709 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2711 inh: &'a Inherited<'a, 'tcx>,
2712 param_env: ty::ParamEnv<'tcx>,
2713 body_id: hir::HirId,
2714 ) -> FnCtxt<'a, 'tcx> {
2718 err_count_on_creation: inh.tcx.sess.err_count(),
2720 ret_coercion_span: RefCell::new(None),
2722 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
2723 diverges: Cell::new(Diverges::Maybe),
2724 has_errors: Cell::new(false),
2725 enclosing_breakables: RefCell::new(EnclosingBreakables {
2727 by_id: Default::default(),
2733 pub fn sess(&self) -> &Session {
2737 pub fn errors_reported_since_creation(&self) -> bool {
2738 self.tcx.sess.err_count() > self.err_count_on_creation
2741 /// Produces warning on the given node, if the current point in the
2742 /// function is unreachable, and there hasn't been another warning.
2743 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2744 // FIXME: Combine these two 'if' expressions into one once
2745 // let chains are implemented
2746 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2747 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2748 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2749 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2750 if !span.is_desugaring(DesugaringKind::CondTemporary)
2751 && !span.is_desugaring(DesugaringKind::Async)
2752 && !orig_span.is_desugaring(DesugaringKind::Await)
2754 self.diverges.set(Diverges::WarnedAlways);
2756 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2758 let msg = format!("unreachable {}", kind);
2760 .struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2761 .span_label(span, &msg)
2764 custom_note.unwrap_or("any code following this expression is unreachable"),
2771 pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
2772 ObligationCause::new(span, self.body_id, code)
2775 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2776 self.cause(span, ObligationCauseCode::MiscObligation)
2779 /// Resolves type and const variables in `ty` if possible. Unlike the infcx
2780 /// version (resolve_vars_if_possible), this version will
2781 /// also select obligations if it seems useful, in an effort
2782 /// to get more type information.
2783 fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2784 debug!("resolve_vars_with_obligations(ty={:?})", ty);
2786 // No Infer()? Nothing needs doing.
2787 if !ty.has_infer_types() && !ty.has_infer_consts() {
2788 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2792 // If `ty` is a type variable, see whether we already know what it is.
2793 ty = self.resolve_vars_if_possible(&ty);
2794 if !ty.has_infer_types() && !ty.has_infer_consts() {
2795 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2799 // If not, try resolving pending obligations as much as
2800 // possible. This can help substantially when there are
2801 // indirect dependencies that don't seem worth tracking
2803 self.select_obligations_where_possible(false, |_| {});
2804 ty = self.resolve_vars_if_possible(&ty);
2806 debug!("resolve_vars_with_obligations: ty={:?}", ty);
2810 fn record_deferred_call_resolution(
2812 closure_def_id: DefId,
2813 r: DeferredCallResolution<'tcx>,
2815 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2816 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2819 fn remove_deferred_call_resolutions(
2821 closure_def_id: DefId,
2822 ) -> Vec<DeferredCallResolution<'tcx>> {
2823 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2824 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2827 pub fn tag(&self) -> String {
2828 format!("{:p}", self)
2831 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2832 self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
2833 span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
2838 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2840 "write_ty({:?}, {:?}) in fcx {}",
2842 self.resolve_vars_if_possible(&ty),
2845 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2847 if ty.references_error() {
2848 self.has_errors.set(true);
2849 self.set_tainted_by_errors();
2853 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2854 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2857 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2858 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2861 pub fn write_method_call(&self, hir_id: hir::HirId, method: MethodCallee<'tcx>) {
2862 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2863 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2864 self.write_substs(hir_id, method.substs);
2866 // When the method is confirmed, the `method.substs` includes
2867 // parameters from not just the method, but also the impl of
2868 // the method -- in particular, the `Self` type will be fully
2869 // resolved. However, those are not something that the "user
2870 // specified" -- i.e., those types come from the inferred type
2871 // of the receiver, not something the user wrote. So when we
2872 // create the user-substs, we want to replace those earlier
2873 // types with just the types that the user actually wrote --
2874 // that is, those that appear on the *method itself*.
2876 // As an example, if the user wrote something like
2877 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2878 // type of `foo` (possibly adjusted), but we don't want to
2879 // include that. We want just the `[_, u32]` part.
2880 if !method.substs.is_noop() {
2881 let method_generics = self.tcx.generics_of(method.def_id);
2882 if !method_generics.params.is_empty() {
2883 let user_type_annotation = self.infcx.probe(|_| {
2884 let user_substs = UserSubsts {
2885 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2886 let i = param.index as usize;
2887 if i < method_generics.parent_count {
2888 self.infcx.var_for_def(DUMMY_SP, param)
2893 user_self_ty: None, // not relevant here
2896 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2902 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2903 self.write_user_type_annotation(hir_id, user_type_annotation);
2908 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2909 if !substs.is_noop() {
2910 debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag());
2912 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2916 /// Given the substs that we just converted from the HIR, try to
2917 /// canonicalize them and store them as user-given substitutions
2918 /// (i.e., substitutions that must be respected by the NLL check).
2920 /// This should be invoked **before any unifications have
2921 /// occurred**, so that annotations like `Vec<_>` are preserved
2923 pub fn write_user_type_annotation_from_substs(
2927 substs: SubstsRef<'tcx>,
2928 user_self_ty: Option<UserSelfTy<'tcx>>,
2931 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2932 user_self_ty={:?} in fcx {}",
2940 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2941 let canonicalized = self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2943 UserSubsts { substs, user_self_ty },
2945 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2946 self.write_user_type_annotation(hir_id, canonicalized);
2950 pub fn write_user_type_annotation(
2953 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2956 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2958 canonical_user_type_annotation,
2962 if !canonical_user_type_annotation.is_identity() {
2965 .user_provided_types_mut()
2966 .insert(hir_id, canonical_user_type_annotation);
2968 debug!("write_user_type_annotation: skipping identity substs");
2972 pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
2973 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2979 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2980 Entry::Vacant(entry) => {
2983 Entry::Occupied(mut entry) => {
2984 debug!(" - composing on top of {:?}", entry.get());
2985 match (&entry.get()[..], &adj[..]) {
2986 // Applying any adjustment on top of a NeverToAny
2987 // is a valid NeverToAny adjustment, because it can't
2989 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2991 Adjustment { kind: Adjust::Deref(_), .. },
2992 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2994 Adjustment { kind: Adjust::Deref(_), .. },
2995 .. // Any following adjustments are allowed.
2997 // A reborrow has no effect before a dereference.
2999 // FIXME: currently we never try to compose autoderefs
3000 // and ReifyFnPointer/UnsafeFnPointer, but we could.
3002 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
3003 expr, entry.get(), adj)
3005 *entry.get_mut() = adj;
3010 /// Basically whenever we are converting from a type scheme into
3011 /// the fn body space, we always want to normalize associated
3012 /// types as well. This function combines the two.
3013 fn instantiate_type_scheme<T>(&self, span: Span, substs: SubstsRef<'tcx>, value: &T) -> T
3015 T: TypeFoldable<'tcx>,
3017 let value = value.subst(self.tcx, substs);
3018 let result = self.normalize_associated_types_in(span, &value);
3019 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}", value, substs, result);
3023 /// As `instantiate_type_scheme`, but for the bounds found in a
3024 /// generic type scheme.
3025 fn instantiate_bounds(
3029 substs: SubstsRef<'tcx>,
3030 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
3031 let bounds = self.tcx.predicates_of(def_id);
3032 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
3033 let result = bounds.instantiate(self.tcx, substs);
3034 let result = self.normalize_associated_types_in(span, &result);
3036 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
3037 bounds, substs, result, spans,
3042 /// Replaces the opaque types from the given value with type variables,
3043 /// and records the `OpaqueTypeMap` for later use during writeback. See
3044 /// `InferCtxt::instantiate_opaque_types` for more details.
3045 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
3047 parent_id: hir::HirId,
3051 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
3053 "instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
3054 parent_def_id, value
3057 let (value, opaque_type_map) =
3058 self.register_infer_ok_obligations(self.instantiate_opaque_types(
3066 let mut opaque_types = self.opaque_types.borrow_mut();
3067 let mut opaque_types_vars = self.opaque_types_vars.borrow_mut();
3068 for (ty, decl) in opaque_type_map {
3069 let _ = opaque_types.insert(ty, decl);
3070 let _ = opaque_types_vars.insert(decl.concrete_ty, decl.opaque_type);
3076 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
3078 T: TypeFoldable<'tcx>,
3080 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
3083 fn normalize_associated_types_in_as_infer_ok<T>(
3087 ) -> InferOk<'tcx, T>
3089 T: TypeFoldable<'tcx>,
3091 self.inh.partially_normalize_associated_types_in(span, self.body_id, self.param_env, value)
3094 pub fn require_type_meets(
3098 code: traits::ObligationCauseCode<'tcx>,
3101 self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
3104 pub fn require_type_is_sized(
3108 code: traits::ObligationCauseCode<'tcx>,
3110 if !ty.references_error() {
3111 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
3112 self.require_type_meets(ty, span, code, lang_item);
3116 pub fn require_type_is_sized_deferred(
3120 code: traits::ObligationCauseCode<'tcx>,
3122 if !ty.references_error() {
3123 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
3127 pub fn register_bound(
3131 cause: traits::ObligationCause<'tcx>,
3133 if !ty.references_error() {
3134 self.fulfillment_cx.borrow_mut().register_bound(
3144 pub fn to_ty(&self, ast_t: &hir::Ty<'_>) -> Ty<'tcx> {
3145 let t = AstConv::ast_ty_to_ty(self, ast_t);
3146 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
3150 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> {
3151 let ty = self.to_ty(ast_ty);
3152 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
3154 if Self::can_contain_user_lifetime_bounds(ty) {
3155 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
3156 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
3157 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
3163 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
3164 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
3165 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
3168 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
3169 AstConv::ast_const_to_const(self, ast_c, ty)
3172 // If the type given by the user has free regions, save it for later, since
3173 // NLL would like to enforce those. Also pass in types that involve
3174 // projections, since those can resolve to `'static` bounds (modulo #54940,
3175 // which hopefully will be fixed by the time you see this comment, dear
3176 // reader, although I have my doubts). Also pass in types with inference
3177 // types, because they may be repeated. Other sorts of things are already
3178 // sufficiently enforced with erased regions. =)
3179 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
3181 T: TypeFoldable<'tcx>,
3183 t.has_free_regions() || t.has_projections() || t.has_infer_types()
3186 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
3187 match self.tables.borrow().node_types().get(id) {
3189 None if self.is_tainted_by_errors() => self.tcx.types.err,
3192 "no type for node {}: {} in fcx {}",
3194 self.tcx.hir().node_to_string(id),
3201 /// Registers an obligation for checking later, during regionck, that the type `ty` must
3202 /// outlive the region `r`.
3203 pub fn register_wf_obligation(
3207 code: traits::ObligationCauseCode<'tcx>,
3209 // WF obligations never themselves fail, so no real need to give a detailed cause:
3210 let cause = traits::ObligationCause::new(span, self.body_id, code);
3211 self.register_predicate(traits::Obligation::new(
3214 ty::Predicate::WellFormed(ty),
3218 /// Registers obligations that all types appearing in `substs` are well-formed.
3219 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr<'_>) {
3220 for ty in substs.types() {
3221 if !ty.references_error() {
3222 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
3227 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
3228 /// type/region parameter was instantiated (`substs`), creates and registers suitable
3229 /// trait/region obligations.
3231 /// For example, if there is a function:
3234 /// fn foo<'a,T:'a>(...)
3237 /// and a reference:
3243 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
3244 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
3245 pub fn add_obligations_for_parameters(
3247 cause: traits::ObligationCause<'tcx>,
3248 predicates: &ty::InstantiatedPredicates<'tcx>,
3250 assert!(!predicates.has_escaping_bound_vars());
3252 debug!("add_obligations_for_parameters(predicates={:?})", predicates);
3254 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
3255 self.register_predicate(obligation);
3259 // FIXME(arielb1): use this instead of field.ty everywhere
3260 // Only for fields! Returns <none> for methods>
3261 // Indifferent to privacy flags
3265 field: &'tcx ty::FieldDef,
3266 substs: SubstsRef<'tcx>,
3268 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
3271 fn check_casts(&self) {
3272 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
3273 for cast in deferred_cast_checks.drain(..) {
3278 fn resolve_generator_interiors(&self, def_id: DefId) {
3279 let mut generators = self.deferred_generator_interiors.borrow_mut();
3280 for (body_id, interior, kind) in generators.drain(..) {
3281 self.select_obligations_where_possible(false, |_| {});
3282 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
3286 // Tries to apply a fallback to `ty` if it is an unsolved variable.
3288 // - Unconstrained ints are replaced with `i32`.
3290 // - Unconstrained floats are replaced with with `f64`.
3292 // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
3293 // is enabled. Otherwise, they are replaced with `()`.
3295 // Fallback becomes very dubious if we have encountered type-checking errors.
3296 // In that case, fallback to Error.
3297 // The return value indicates whether fallback has occurred.
3298 fn fallback_if_possible(&self, ty: Ty<'tcx>, mode: FallbackMode) -> bool {
3299 use rustc::ty::error::UnconstrainedNumeric::Neither;
3300 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt};
3302 assert!(ty.is_ty_infer());
3303 let fallback = match self.type_is_unconstrained_numeric(ty) {
3304 _ if self.is_tainted_by_errors() => self.tcx().types.err,
3305 UnconstrainedInt => self.tcx.types.i32,
3306 UnconstrainedFloat => self.tcx.types.f64,
3307 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
3309 // This type variable was created from the instantiation of an opaque
3310 // type. The fact that we're attempting to perform fallback for it
3311 // means that the function neither constrained it to a concrete
3312 // type, nor to the opaque type itself.
3314 // For example, in this code:
3317 // type MyType = impl Copy;
3318 // fn defining_use() -> MyType { true }
3319 // fn other_use() -> MyType { defining_use() }
3322 // `defining_use` will constrain the instantiated inference
3323 // variable to `bool`, while `other_use` will constrain
3324 // the instantiated inference variable to `MyType`.
3326 // When we process opaque types during writeback, we
3327 // will handle cases like `other_use`, and not count
3328 // them as defining usages
3330 // However, we also need to handle cases like this:
3333 // pub type Foo = impl Copy;
3334 // fn produce() -> Option<Foo> {
3339 // In the above snippet, the inference varaible created by
3340 // instantiating `Option<Foo>` will be completely unconstrained.
3341 // We treat this as a non-defining use by making the inference
3342 // variable fall back to the opaque type itself.
3343 if let FallbackMode::All = mode {
3344 if let Some(opaque_ty) = self.opaque_types_vars.borrow().get(ty) {
3346 "fallback_if_possible: falling back opaque type var {:?} to {:?}",
3358 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
3359 self.demand_eqtype(rustc_span::DUMMY_SP, ty, fallback);
3363 fn select_all_obligations_or_error(&self) {
3364 debug!("select_all_obligations_or_error");
3365 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
3366 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
3370 /// Select as many obligations as we can at present.
3371 fn select_obligations_where_possible(
3373 fallback_has_occurred: bool,
3374 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
3376 let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
3377 if let Err(mut errors) = result {
3378 mutate_fullfillment_errors(&mut errors);
3379 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
3383 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
3384 /// returns a type of `&T`, but the actual type we assign to the
3385 /// *expression* is `T`. So this function just peels off the return
3386 /// type by one layer to yield `T`.
3387 fn make_overloaded_place_return_type(
3389 method: MethodCallee<'tcx>,
3390 ) -> ty::TypeAndMut<'tcx> {
3391 // extract method return type, which will be &T;
3392 let ret_ty = method.sig.output();
3394 // method returns &T, but the type as visible to user is T, so deref
3395 ret_ty.builtin_deref(true).unwrap()
3400 expr: &hir::Expr<'_>,
3401 base_expr: &'tcx hir::Expr<'tcx>,
3405 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3406 // FIXME(#18741) -- this is almost but not quite the same as the
3407 // autoderef that normal method probing does. They could likely be
3410 let mut autoderef = self.autoderef(base_expr.span, base_ty);
3411 let mut result = None;
3412 while result.is_none() && autoderef.next().is_some() {
3413 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
3415 autoderef.finalize(self);
3419 /// To type-check `base_expr[index_expr]`, we progressively autoderef
3420 /// (and otherwise adjust) `base_expr`, looking for a type which either
3421 /// supports builtin indexing or overloaded indexing.
3422 /// This loop implements one step in that search; the autoderef loop
3423 /// is implemented by `lookup_indexing`.
3426 expr: &hir::Expr<'_>,
3427 base_expr: &hir::Expr<'_>,
3428 autoderef: &Autoderef<'a, 'tcx>,
3431 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
3432 let adjusted_ty = autoderef.unambiguous_final_ty(self);
3434 "try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
3436 expr, base_expr, adjusted_ty, index_ty
3439 for &unsize in &[false, true] {
3440 let mut self_ty = adjusted_ty;
3442 // We only unsize arrays here.
3443 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3444 self_ty = self.tcx.mk_slice(element_ty);
3450 // If some lookup succeeds, write callee into table and extract index/element
3451 // type from the method signature.
3452 // If some lookup succeeded, install method in table
3453 let input_ty = self.next_ty_var(TypeVariableOrigin {
3454 kind: TypeVariableOriginKind::AutoDeref,
3455 span: base_expr.span,
3457 let method = self.try_overloaded_place_op(
3465 let result = method.map(|ok| {
3466 debug!("try_index_step: success, using overloaded indexing");
3467 let method = self.register_infer_ok_obligations(ok);
3469 let mut adjustments = autoderef.adjust_steps(self, needs);
3470 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3471 let mutbl = match r_mutbl {
3472 hir::Mutability::Not => AutoBorrowMutability::Not,
3473 hir::Mutability::Mut => AutoBorrowMutability::Mut {
3474 // Indexing can be desugared to a method call,
3475 // so maybe we could use two-phase here.
3476 // See the documentation of AllowTwoPhase for why that's
3477 // not the case today.
3478 allow_two_phase_borrow: AllowTwoPhase::No,
3481 adjustments.push(Adjustment {
3482 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3485 .mk_ref(region, ty::TypeAndMut { mutbl: r_mutbl, ty: adjusted_ty }),
3489 adjustments.push(Adjustment {
3490 kind: Adjust::Pointer(PointerCast::Unsize),
3491 target: method.sig.inputs()[0],
3494 self.apply_adjustments(base_expr, adjustments);
3496 self.write_method_call(expr.hir_id, method);
3497 (input_ty, self.make_overloaded_place_return_type(method).ty)
3499 if result.is_some() {
3507 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3508 let (tr, name) = match (op, is_mut) {
3509 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3510 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3511 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3512 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3514 (tr, ast::Ident::with_dummy_span(name))
3517 fn try_overloaded_place_op(
3521 arg_tys: &[Ty<'tcx>],
3524 ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
3525 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})", span, base_ty, needs, op);
3527 // Try Mut first, if needed.
3528 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3529 let method = match (needs, mut_tr) {
3530 (Needs::MutPlace, Some(trait_did)) => {
3531 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3536 // Otherwise, fall back to the immutable version.
3537 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3538 let method = match (method, imm_tr) {
3539 (None, Some(trait_did)) => {
3540 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3542 (method, _) => method,
3548 fn check_method_argument_types(
3551 expr: &'tcx hir::Expr<'tcx>,
3552 method: Result<MethodCallee<'tcx>, ()>,
3553 args_no_rcvr: &'tcx [hir::Expr<'tcx>],
3554 tuple_arguments: TupleArgumentsFlag,
3555 expected: Expectation<'tcx>,
3557 let has_error = match method {
3558 Ok(method) => method.substs.references_error() || method.sig.references_error(),
3562 let err_inputs = self.err_args(args_no_rcvr.len());
3564 let err_inputs = match tuple_arguments {
3565 DontTupleArguments => err_inputs,
3566 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3569 self.check_argument_types(
3579 return self.tcx.types.err;
3582 let method = method.unwrap();
3583 // HACK(eddyb) ignore self in the definition (see above).
3584 let expected_arg_tys = self.expected_inputs_for_expected_output(
3587 method.sig.output(),
3588 &method.sig.inputs()[1..],
3590 self.check_argument_types(
3593 &method.sig.inputs()[1..],
3594 &expected_arg_tys[..],
3596 method.sig.c_variadic,
3598 self.tcx.hir().span_if_local(method.def_id),
3603 fn self_type_matches_expected_vid(
3605 trait_ref: ty::PolyTraitRef<'tcx>,
3606 expected_vid: ty::TyVid,
3608 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3610 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3611 trait_ref, self_ty, expected_vid
3613 match self_ty.kind {
3614 ty::Infer(ty::TyVar(found_vid)) => {
3615 // FIXME: consider using `sub_root_var` here so we
3616 // can see through subtyping.
3617 let found_vid = self.root_var(found_vid);
3618 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3619 expected_vid == found_vid
3625 fn obligations_for_self_ty<'b>(
3628 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3631 // FIXME: consider using `sub_root_var` here so we
3632 // can see through subtyping.
3633 let ty_var_root = self.root_var(self_ty);
3635 "obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3638 self.fulfillment_cx.borrow().pending_obligations()
3643 .pending_obligations()
3645 .filter_map(move |obligation| match obligation.predicate {
3646 ty::Predicate::Projection(ref data) => {
3647 Some((data.to_poly_trait_ref(self.tcx), obligation))
3649 ty::Predicate::Trait(ref data) => Some((data.to_poly_trait_ref(), obligation)),
3650 ty::Predicate::Subtype(..) => None,
3651 ty::Predicate::RegionOutlives(..) => None,
3652 ty::Predicate::TypeOutlives(..) => None,
3653 ty::Predicate::WellFormed(..) => None,
3654 ty::Predicate::ObjectSafe(..) => None,
3655 ty::Predicate::ConstEvaluatable(..) => None,
3656 // N.B., this predicate is created by breaking down a
3657 // `ClosureType: FnFoo()` predicate, where
3658 // `ClosureType` represents some `Closure`. It can't
3659 // possibly be referring to the current closure,
3660 // because we haven't produced the `Closure` for
3661 // this closure yet; this is exactly why the other
3662 // code is looking for a self type of a unresolved
3663 // inference variable.
3664 ty::Predicate::ClosureKind(..) => None,
3666 .filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3669 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3670 self.obligations_for_self_ty(self_ty)
3671 .any(|(tr, _)| Some(tr.def_id()) == self.tcx.lang_items().sized_trait())
3674 /// Generic function that factors out common logic from function calls,
3675 /// method calls and overloaded operators.
3676 fn check_argument_types(
3679 expr: &'tcx hir::Expr<'tcx>,
3680 fn_inputs: &[Ty<'tcx>],
3681 expected_arg_tys: &[Ty<'tcx>],
3682 args: &'tcx [hir::Expr<'tcx>],
3684 tuple_arguments: TupleArgumentsFlag,
3685 def_span: Option<Span>,
3688 // Grab the argument types, supplying fresh type variables
3689 // if the wrong number of arguments were supplied
3690 let supplied_arg_count = if tuple_arguments == DontTupleArguments { args.len() } else { 1 };
3692 // All the input types from the fn signature must outlive the call
3693 // so as to validate implied bounds.
3694 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3695 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3698 let expected_arg_count = fn_inputs.len();
3700 let param_count_error = |expected_count: usize,
3705 let mut err = tcx.sess.struct_span_err_with_code(
3708 "this function takes {}{} but {} {} supplied",
3709 if c_variadic { "at least " } else { "" },
3710 potentially_plural_count(expected_count, "parameter"),
3711 potentially_plural_count(arg_count, "parameter"),
3712 if arg_count == 1 { "was" } else { "were" }
3714 DiagnosticId::Error(error_code.to_owned()),
3717 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3718 err.span_label(def_s, "defined here");
3721 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3722 // remove closing `)` from the span
3723 let sugg_span = sugg_span.shrink_to_lo();
3724 err.span_suggestion(
3726 "expected the unit value `()`; create it with empty parentheses",
3728 Applicability::MachineApplicable,
3735 if c_variadic { "at least " } else { "" },
3736 potentially_plural_count(expected_count, "parameter")
3743 let mut expected_arg_tys = expected_arg_tys.to_vec();
3745 let formal_tys = if tuple_arguments == TupleArguments {
3746 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3747 match tuple_type.kind {
3748 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3749 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3750 expected_arg_tys = vec![];
3751 self.err_args(args.len())
3753 ty::Tuple(arg_types) => {
3754 expected_arg_tys = match expected_arg_tys.get(0) {
3755 Some(&ty) => match ty.kind {
3756 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3761 arg_types.iter().map(|k| k.expect_ty()).collect()
3768 "cannot use call notation; the first type parameter \
3769 for the function trait is neither a tuple nor unit"
3771 expected_arg_tys = vec![];
3772 self.err_args(args.len())
3775 } else if expected_arg_count == supplied_arg_count {
3777 } else if c_variadic {
3778 if supplied_arg_count >= expected_arg_count {
3781 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3782 expected_arg_tys = vec![];
3783 self.err_args(supplied_arg_count)
3786 // is the missing argument of type `()`?
3787 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3788 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3789 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3790 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3794 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3796 expected_arg_tys = vec![];
3797 self.err_args(supplied_arg_count)
3801 "check_argument_types: formal_tys={:?}",
3802 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>()
3805 // If there is no expectation, expect formal_tys.
3806 let expected_arg_tys =
3807 if !expected_arg_tys.is_empty() { expected_arg_tys } else { formal_tys.clone() };
3809 let mut final_arg_types: Vec<(usize, Ty<'_>, Ty<'_>)> = vec![];
3811 // Check the arguments.
3812 // We do this in a pretty awful way: first we type-check any arguments
3813 // that are not closures, then we type-check the closures. This is so
3814 // that we have more information about the types of arguments when we
3815 // type-check the functions. This isn't really the right way to do this.
3816 for &check_closures in &[false, true] {
3817 debug!("check_closures={}", check_closures);
3819 // More awful hacks: before we check argument types, try to do
3820 // an "opportunistic" vtable resolution of any trait bounds on
3821 // the call. This helps coercions.
3823 self.select_obligations_where_possible(false, |errors| {
3824 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3825 self.point_at_arg_instead_of_call_if_possible(
3827 &final_arg_types[..],
3834 // For C-variadic functions, we don't have a declared type for all of
3835 // the arguments hence we only do our usual type checking with
3836 // the arguments who's types we do know.
3837 let t = if c_variadic {
3839 } else if tuple_arguments == TupleArguments {
3844 for (i, arg) in args.iter().take(t).enumerate() {
3845 // Warn only for the first loop (the "no closures" one).
3846 // Closure arguments themselves can't be diverging, but
3847 // a previous argument can, e.g., `foo(panic!(), || {})`.
3848 if !check_closures {
3849 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3852 let is_closure = match arg.kind {
3853 ExprKind::Closure(..) => true,
3857 if is_closure != check_closures {
3861 debug!("checking the argument");
3862 let formal_ty = formal_tys[i];
3864 // The special-cased logic below has three functions:
3865 // 1. Provide as good of an expected type as possible.
3866 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3868 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3870 // 2. Coerce to the most detailed type that could be coerced
3871 // to, which is `expected_ty` if `rvalue_hint` returns an
3872 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3873 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3874 // We're processing function arguments so we definitely want to use
3875 // two-phase borrows.
3876 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3877 final_arg_types.push((i, checked_ty, coerce_ty));
3879 // 3. Relate the expected type and the formal one,
3880 // if the expected type was used for the coercion.
3881 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3885 // We also need to make sure we at least write the ty of the other
3886 // arguments which we skipped above.
3888 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3889 use crate::structured_errors::{StructuredDiagnostic, VariadicError};
3890 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3893 for arg in args.iter().skip(expected_arg_count) {
3894 let arg_ty = self.check_expr(&arg);
3896 // There are a few types which get autopromoted when passed via varargs
3897 // in C but we just error out instead and require explicit casts.
3898 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3900 ty::Float(ast::FloatTy::F32) => {
3901 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3903 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3904 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3906 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3907 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3910 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3911 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3912 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3920 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3921 vec![self.tcx.types.err; len]
3924 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call argument expressions, we walk
3925 /// the checked and coerced types for each argument to see if any of the `FulfillmentError`s
3926 /// reference a type argument. The reason to walk also the checked type is that the coerced type
3927 /// can be not easily comparable with predicate type (because of coercion). If the types match
3928 /// for either checked or coerced type, and there's only *one* argument that does, we point at
3929 /// the corresponding argument's expression span instead of the `fn` call path span.
3930 fn point_at_arg_instead_of_call_if_possible(
3932 errors: &mut Vec<traits::FulfillmentError<'_>>,
3933 final_arg_types: &[(usize, Ty<'tcx>, Ty<'tcx>)],
3935 args: &'tcx [hir::Expr<'tcx>],
3937 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3938 // the `?` operator.
3939 if call_sp.desugaring_kind().is_some() {
3943 for error in errors {
3944 // Only if the cause is somewhere inside the expression we want try to point at arg.
3945 // Otherwise, it means that the cause is somewhere else and we should not change
3946 // anything because we can break the correct span.
3947 if !call_sp.contains(error.obligation.cause.span) {
3951 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3952 // Collect the argument position for all arguments that could have caused this
3953 // `FulfillmentError`.
3954 let mut referenced_in = final_arg_types
3956 .map(|(i, checked_ty, _)| (i, checked_ty))
3957 .chain(final_arg_types.iter().map(|(i, _, coerced_ty)| (i, coerced_ty)))
3958 .flat_map(|(i, ty)| {
3959 let ty = self.resolve_vars_if_possible(ty);
3960 // We walk the argument type because the argument's type could have
3961 // been `Option<T>`, but the `FulfillmentError` references `T`.
3963 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3966 .collect::<Vec<_>>();
3968 // Both checked and coerced types could have matched, thus we need to remove
3970 referenced_in.dedup();
3972 if let (Some(ref_in), None) = (referenced_in.pop(), referenced_in.pop()) {
3973 // We make sure that only *one* argument matches the obligation failure
3974 // and we assign the obligation's span to its expression's.
3975 error.obligation.cause.span = args[ref_in].span;
3976 error.points_at_arg_span = true;
3982 /// Given a vec of evaluated `FulfillmentError`s and an `fn` call expression, we walk the
3983 /// `PathSegment`s and resolve their type parameters to see if any of the `FulfillmentError`s
3984 /// were caused by them. If they were, we point at the corresponding type argument's span
3985 /// instead of the `fn` call path span.
3986 fn point_at_type_arg_instead_of_call_if_possible(
3988 errors: &mut Vec<traits::FulfillmentError<'_>>,
3989 call_expr: &'tcx hir::Expr<'tcx>,
3991 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3992 if let hir::ExprKind::Path(qpath) = &path.kind {
3993 if let hir::QPath::Resolved(_, path) = &qpath {
3994 for error in errors {
3995 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3996 // If any of the type arguments in this path segment caused the
3997 // `FullfillmentError`, point at its span (#61860).
4001 .filter_map(|seg| seg.args.as_ref())
4002 .flat_map(|a| a.args.iter())
4004 if let hir::GenericArg::Type(hir_ty) = &arg {
4005 if let hir::TyKind::Path(hir::QPath::TypeRelative(..)) =
4008 // Avoid ICE with associated types. As this is best
4009 // effort only, it's ok to ignore the case. It
4010 // would trigger in `is_send::<T::AssocType>();`
4011 // from `typeck-default-trait-impl-assoc-type.rs`.
4013 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
4014 let ty = self.resolve_vars_if_possible(&ty);
4015 if ty == predicate.skip_binder().self_ty() {
4016 error.obligation.cause.span = hir_ty.span;
4028 // AST fragment checking
4029 fn check_lit(&self, lit: &hir::Lit, expected: Expectation<'tcx>) -> Ty<'tcx> {
4033 ast::LitKind::Str(..) => tcx.mk_static_str(),
4034 ast::LitKind::ByteStr(ref v) => {
4035 tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_array(tcx.types.u8, v.len() as u64))
4037 ast::LitKind::Byte(_) => tcx.types.u8,
4038 ast::LitKind::Char(_) => tcx.types.char,
4039 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
4040 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
4041 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
4042 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4043 ty::Int(_) | ty::Uint(_) => Some(ty),
4044 ty::Char => Some(tcx.types.u8),
4045 ty::RawPtr(..) => Some(tcx.types.usize),
4046 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
4049 opt_ty.unwrap_or_else(|| self.next_int_var())
4051 ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => tcx.mk_mach_float(t),
4052 ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
4053 let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind {
4054 ty::Float(_) => Some(ty),
4057 opt_ty.unwrap_or_else(|| self.next_float_var())
4059 ast::LitKind::Bool(_) => tcx.types.bool,
4060 ast::LitKind::Err(_) => tcx.types.err,
4064 // Determine the `Self` type, using fresh variables for all variables
4065 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
4066 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
4068 pub fn impl_self_ty(
4070 span: Span, // (potential) receiver for this impl
4072 ) -> TypeAndSubsts<'tcx> {
4073 let ity = self.tcx.type_of(did);
4074 debug!("impl_self_ty: ity={:?}", ity);
4076 let substs = self.fresh_substs_for_item(span, did);
4077 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
4079 TypeAndSubsts { substs: substs, ty: substd_ty }
4082 /// Unifies the output type with the expected type early, for more coercions
4083 /// and forward type information on the input expressions.
4084 fn expected_inputs_for_expected_output(
4087 expected_ret: Expectation<'tcx>,
4088 formal_ret: Ty<'tcx>,
4089 formal_args: &[Ty<'tcx>],
4090 ) -> Vec<Ty<'tcx>> {
4091 let formal_ret = self.resolve_vars_with_obligations(formal_ret);
4092 let ret_ty = match expected_ret.only_has_type(self) {
4094 None => return Vec::new(),
4096 let expect_args = self
4097 .fudge_inference_if_ok(|| {
4098 // Attempt to apply a subtyping relationship between the formal
4099 // return type (likely containing type variables if the function
4100 // is polymorphic) and the expected return type.
4101 // No argument expectations are produced if unification fails.
4102 let origin = self.misc(call_span);
4103 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
4105 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
4106 // to identity so the resulting type is not constrained.
4109 // Process any obligations locally as much as
4110 // we can. We don't care if some things turn
4111 // out unconstrained or ambiguous, as we're
4112 // just trying to get hints here.
4113 self.save_and_restore_in_snapshot_flag(|_| {
4114 let mut fulfill = TraitEngine::new(self.tcx);
4115 for obligation in ok.obligations {
4116 fulfill.register_predicate_obligation(self, obligation);
4118 fulfill.select_where_possible(self)
4122 Err(_) => return Err(()),
4125 // Record all the argument types, with the substitutions
4126 // produced from the above subtyping unification.
4127 Ok(formal_args.iter().map(|ty| self.resolve_vars_if_possible(ty)).collect())
4129 .unwrap_or_default();
4131 "expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
4132 formal_args, formal_ret, expect_args, expected_ret
4137 pub fn check_struct_path(
4141 ) -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
4142 let path_span = match *qpath {
4143 QPath::Resolved(_, ref path) => path.span,
4144 QPath::TypeRelative(ref qself, _) => qself.span,
4146 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
4147 let variant = match def {
4149 self.set_tainted_by_errors();
4152 Res::Def(DefKind::Variant, _) => match ty.kind {
4153 ty::Adt(adt, substs) => Some((adt.variant_of_res(def), adt.did, substs)),
4154 _ => bug!("unexpected type: {:?}", ty),
4156 Res::Def(DefKind::Struct, _)
4157 | Res::Def(DefKind::Union, _)
4158 | Res::Def(DefKind::TyAlias, _)
4159 | Res::Def(DefKind::AssocTy, _)
4160 | Res::SelfTy(..) => match ty.kind {
4161 ty::Adt(adt, substs) if !adt.is_enum() => {
4162 Some((adt.non_enum_variant(), adt.did, substs))
4166 _ => bug!("unexpected definition: {:?}", def),
4169 if let Some((variant, did, substs)) = variant {
4170 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
4171 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
4173 // Check bounds on type arguments used in the path.
4174 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
4176 traits::ObligationCause::new(path_span, self.body_id, traits::ItemObligation(did));
4177 self.add_obligations_for_parameters(cause, &bounds);
4185 "expected struct, variant or union type, found {}",
4186 ty.sort_string(self.tcx)
4188 .span_label(path_span, "not a struct")
4194 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
4195 // The newly resolved definition is written into `type_dependent_defs`.
4196 fn finish_resolving_struct_path(
4201 ) -> (Res, Ty<'tcx>) {
4203 QPath::Resolved(ref maybe_qself, ref path) => {
4204 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
4205 let ty = AstConv::res_to_ty(self, self_ty, path, true);
4208 QPath::TypeRelative(ref qself, ref segment) => {
4209 let ty = self.to_ty(qself);
4211 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
4217 AstConv::associated_path_to_ty(self, hir_id, path_span, ty, res, segment, true);
4218 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
4219 let result = result.map(|(_, kind, def_id)| (kind, def_id));
4221 // Write back the new resolution.
4222 self.write_resolution(hir_id, result);
4224 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
4229 /// Resolves an associated value path into a base type and associated constant, or method
4230 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
4231 pub fn resolve_ty_and_res_ufcs<'b>(
4233 qpath: &'b QPath<'b>,
4236 ) -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]) {
4237 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
4238 let (ty, qself, item_segment) = match *qpath {
4239 QPath::Resolved(ref opt_qself, ref path) => {
4242 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
4246 QPath::TypeRelative(ref qself, ref segment) => (self.to_ty(qself), qself, segment),
4248 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
4249 // Return directly on cache hit. This is useful to avoid doubly reporting
4250 // errors with default match binding modes. See #44614.
4252 cached_result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err);
4253 return (def, Some(ty), slice::from_ref(&**item_segment));
4255 let item_name = item_segment.ident;
4256 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
4257 let result = match error {
4258 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
4259 _ => Err(ErrorReported),
4261 if item_name.name != kw::Invalid {
4262 self.report_method_error(
4266 SelfSource::QPath(qself),
4270 .map(|mut e| e.emit());
4275 // Write back the new resolution.
4276 self.write_resolution(hir_id, result);
4278 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
4280 slice::from_ref(&**item_segment),
4284 pub fn check_decl_initializer(
4286 local: &'tcx hir::Local<'tcx>,
4287 init: &'tcx hir::Expr<'tcx>,
4289 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
4290 // for #42640 (default match binding modes).
4293 let ref_bindings = local.pat.contains_explicit_ref_binding();
4295 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
4296 if let Some(m) = ref_bindings {
4297 // Somewhat subtle: if we have a `ref` binding in the pattern,
4298 // we want to avoid introducing coercions for the RHS. This is
4299 // both because it helps preserve sanity and, in the case of
4300 // ref mut, for soundness (issue #23116). In particular, in
4301 // the latter case, we need to be clear that the type of the
4302 // referent for the reference that results is *equal to* the
4303 // type of the place it is referencing, and not some
4304 // supertype thereof.
4305 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
4306 self.demand_eqtype(init.span, local_ty, init_ty);
4309 self.check_expr_coercable_to_type(init, local_ty)
4313 /// Type check a `let` statement.
4314 pub fn check_decl_local(&self, local: &'tcx hir::Local<'tcx>) {
4315 // Determine and write the type which we'll check the pattern against.
4316 let ty = self.local_ty(local.span, local.hir_id).decl_ty;
4317 self.write_ty(local.hir_id, ty);
4319 // Type check the initializer.
4320 if let Some(ref init) = local.init {
4321 let init_ty = self.check_decl_initializer(local, &init);
4322 self.overwrite_local_ty_if_err(local, ty, init_ty);
4325 // Does the expected pattern type originate from an expression and what is the span?
4326 let (origin_expr, ty_span) = match (local.ty, local.init) {
4327 (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type.
4328 (_, Some(init)) => (true, Some(init.span)), // No explicit type; so use the scrutinee.
4329 _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained.
4332 // Type check the pattern. Override if necessary to avoid knock-on errors.
4333 self.check_pat_top(&local.pat, ty, ty_span, origin_expr);
4334 let pat_ty = self.node_ty(local.pat.hir_id);
4335 self.overwrite_local_ty_if_err(local, ty, pat_ty);
4338 fn overwrite_local_ty_if_err(
4340 local: &'tcx hir::Local<'tcx>,
4344 if ty.references_error() {
4345 // Override the types everywhere with `types.err` to avoid knock on errors.
4346 self.write_ty(local.hir_id, ty);
4347 self.write_ty(local.pat.hir_id, ty);
4348 let local_ty = LocalTy { decl_ty, revealed_ty: ty };
4349 self.locals.borrow_mut().insert(local.hir_id, local_ty);
4350 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
4354 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
4355 err.span_suggestion_short(
4356 span.shrink_to_hi(),
4357 "consider using a semicolon here",
4359 Applicability::MachineApplicable,
4363 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
4364 // Don't do all the complex logic below for `DeclItem`.
4366 hir::StmtKind::Item(..) => return,
4367 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
4370 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
4372 // Hide the outer diverging and `has_errors` flags.
4373 let old_diverges = self.diverges.get();
4374 let old_has_errors = self.has_errors.get();
4375 self.diverges.set(Diverges::Maybe);
4376 self.has_errors.set(false);
4379 hir::StmtKind::Local(ref l) => {
4380 self.check_decl_local(&l);
4383 hir::StmtKind::Item(_) => {}
4384 hir::StmtKind::Expr(ref expr) => {
4385 // Check with expected type of `()`.
4387 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
4388 self.suggest_semicolon_at_end(expr.span, err);
4391 hir::StmtKind::Semi(ref expr) => {
4392 self.check_expr(&expr);
4396 // Combine the diverging and `has_error` flags.
4397 self.diverges.set(self.diverges.get() | old_diverges);
4398 self.has_errors.set(self.has_errors.get() | old_has_errors);
4401 pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
4402 let unit = self.tcx.mk_unit();
4403 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
4405 // if the block produces a `!` value, that can always be
4406 // (effectively) coerced to unit.
4408 self.demand_suptype(blk.span, unit, ty);
4412 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
4413 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
4414 /// when given code like the following:
4416 /// if false { return 0i32; } else { 1u32 }
4417 /// // ^^^^ point at this instead of the whole `if` expression
4419 fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
4420 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
4421 let arm_spans: Vec<Span> = arms
4424 self.in_progress_tables
4425 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
4426 .and_then(|arm_ty| {
4427 if arm_ty.is_never() {
4430 Some(match &arm.body.kind {
4431 // Point at the tail expression when possible.
4432 hir::ExprKind::Block(block, _) => {
4433 block.expr.as_ref().map(|e| e.span).unwrap_or(block.span)
4441 if arm_spans.len() == 1 {
4442 return arm_spans[0];
4448 fn check_block_with_expected(
4450 blk: &'tcx hir::Block<'tcx>,
4451 expected: Expectation<'tcx>,
4454 let mut fcx_ps = self.ps.borrow_mut();
4455 let unsafety_state = fcx_ps.recurse(blk);
4456 replace(&mut *fcx_ps, unsafety_state)
4459 // In some cases, blocks have just one exit, but other blocks
4460 // can be targeted by multiple breaks. This can happen both
4461 // with labeled blocks as well as when we desugar
4462 // a `try { ... }` expression.
4466 // 'a: { if true { break 'a Err(()); } Ok(()) }
4468 // Here we would wind up with two coercions, one from
4469 // `Err(())` and the other from the tail expression
4470 // `Ok(())`. If the tail expression is omitted, that's a
4471 // "forced unit" -- unless the block diverges, in which
4472 // case we can ignore the tail expression (e.g., `'a: {
4473 // break 'a 22; }` would not force the type of the block
4475 let tail_expr = blk.expr.as_ref();
4476 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4477 let coerce = if blk.targeted_by_break {
4478 CoerceMany::new(coerce_to_ty)
4480 let tail_expr: &[&hir::Expr<'_>] = match tail_expr {
4481 Some(e) => slice::from_ref(e),
4484 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4487 let prev_diverges = self.diverges.get();
4488 let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
4490 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4491 for s in blk.stmts {
4495 // check the tail expression **without** holding the
4496 // `enclosing_breakables` lock below.
4497 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4499 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4500 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4501 let coerce = ctxt.coerce.as_mut().unwrap();
4502 if let Some(tail_expr_ty) = tail_expr_ty {
4503 let tail_expr = tail_expr.unwrap();
4504 let span = self.get_expr_coercion_span(tail_expr);
4505 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4506 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4508 // Subtle: if there is no explicit tail expression,
4509 // that is typically equivalent to a tail expression
4510 // of `()` -- except if the block diverges. In that
4511 // case, there is no value supplied from the tail
4512 // expression (assuming there are no other breaks,
4513 // this implies that the type of the block will be
4516 // #41425 -- label the implicit `()` as being the
4517 // "found type" here, rather than the "expected type".
4518 if !self.diverges.get().is_always() {
4519 // #50009 -- Do not point at the entire fn block span, point at the return type
4520 // span, as it is the cause of the requirement, and
4521 // `consider_hint_about_removing_semicolon` will point at the last expression
4522 // if it were a relevant part of the error. This improves usability in editors
4523 // that highlight errors inline.
4524 let mut sp = blk.span;
4525 let mut fn_span = None;
4526 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4527 let ret_sp = decl.output.span();
4528 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4529 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4530 // output would otherwise be incorrect and even misleading. Make sure
4531 // the span we're aiming at correspond to a `fn` body.
4532 if block_sp == blk.span {
4534 fn_span = Some(ident.span);
4538 coerce.coerce_forced_unit(
4542 if let Some(expected_ty) = expected.only_has_type(self) {
4543 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4545 if let Some(fn_span) = fn_span {
4548 "implicitly returns `()` as its body has no tail or `return` \
4560 // If we can break from the block, then the block's exit is always reachable
4561 // (... as long as the entry is reachable) - regardless of the tail of the block.
4562 self.diverges.set(prev_diverges);
4565 let mut ty = ctxt.coerce.unwrap().complete(self);
4567 if self.has_errors.get() || ty.references_error() {
4568 ty = self.tcx.types.err
4571 self.write_ty(blk.hir_id, ty);
4573 *self.ps.borrow_mut() = prev;
4577 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4578 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4580 Node::Item(&hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })
4581 | Node::ImplItem(&hir::ImplItem {
4582 kind: hir::ImplItemKind::Method(_, body_id), ..
4584 let body = self.tcx.hir().body(body_id);
4585 if let ExprKind::Block(block, _) = &body.value.kind {
4586 return Some(block.span);
4594 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4595 fn get_parent_fn_decl(
4598 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident)> {
4599 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4600 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4603 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4604 fn get_node_fn_decl(
4607 ) -> Option<(&'tcx hir::FnDecl<'tcx>, ast::Ident, bool)> {
4609 Node::Item(&hir::Item { ident, kind: hir::ItemKind::Fn(ref sig, ..), .. }) => {
4610 // This is less than ideal, it will not suggest a return type span on any
4611 // method called `main`, regardless of whether it is actually the entry point,
4612 // but it will still present it as the reason for the expected type.
4613 Some((&sig.decl, ident, ident.name != sym::main))
4615 Node::TraitItem(&hir::TraitItem {
4617 kind: hir::TraitItemKind::Method(ref sig, ..),
4619 }) => Some((&sig.decl, ident, true)),
4620 Node::ImplItem(&hir::ImplItem {
4622 kind: hir::ImplItemKind::Method(ref sig, ..),
4624 }) => Some((&sig.decl, ident, false)),
4629 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4630 /// suggestion can be made, `None` otherwise.
4631 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl<'tcx>, bool)> {
4632 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4633 // `while` before reaching it, as block tail returns are not available in them.
4634 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4635 let parent = self.tcx.hir().get(blk_id);
4636 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4640 /// On implicit return expressions with mismatched types, provides the following suggestions:
4642 /// - Points out the method's return type as the reason for the expected type.
4643 /// - Possible missing semicolon.
4644 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4645 pub fn suggest_mismatched_types_on_tail(
4647 err: &mut DiagnosticBuilder<'_>,
4648 expr: &'tcx hir::Expr<'tcx>,
4654 let expr = expr.peel_drop_temps();
4655 self.suggest_missing_semicolon(err, expr, expected, cause_span);
4656 let mut pointing_at_return_type = false;
4657 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4658 pointing_at_return_type =
4659 self.suggest_missing_return_type(err, &fn_decl, expected, found, can_suggest);
4661 pointing_at_return_type
4664 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4665 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4667 /// fn foo(x: usize) -> usize { x }
4668 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4672 err: &mut DiagnosticBuilder<'_>,
4673 expr: &hir::Expr<'_>,
4677 let hir = self.tcx.hir();
4678 let (def_id, sig) = match found.kind {
4679 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4680 ty::Closure(def_id, substs) => {
4681 // We don't use `closure_sig` to account for malformed closures like
4682 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4683 let closure_sig_ty = substs.as_closure().sig_ty(def_id, self.tcx);
4686 match closure_sig_ty.kind {
4687 ty::FnPtr(sig) => sig,
4695 let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig).0;
4696 let sig = self.normalize_associated_types_in(expr.span, &sig);
4697 if self.can_coerce(sig.output(), expected) {
4698 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4699 (String::new(), Applicability::MachineApplicable)
4701 ("...".to_string(), Applicability::HasPlaceholders)
4703 let mut msg = "call this function";
4704 match hir.get_if_local(def_id) {
4705 Some(Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. }))
4706 | Some(Node::ImplItem(hir::ImplItem {
4707 kind: hir::ImplItemKind::Method(_, body_id),
4710 | Some(Node::TraitItem(hir::TraitItem {
4711 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4714 let body = hir.body(*body_id);
4718 .map(|param| match ¶m.pat.kind {
4719 hir::PatKind::Binding(_, _, ident, None)
4720 if ident.name != kw::SelfLower =>
4724 _ => "_".to_string(),
4726 .collect::<Vec<_>>()
4729 Some(Node::Expr(hir::Expr {
4730 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4731 span: full_closure_span,
4734 if *full_closure_span == expr.span {
4737 err.span_label(*closure_span, "closure defined here");
4738 msg = "call this closure";
4739 let body = hir.body(*body_id);
4743 .map(|param| match ¶m.pat.kind {
4744 hir::PatKind::Binding(_, _, ident, None)
4745 if ident.name != kw::SelfLower =>
4749 _ => "_".to_string(),
4751 .collect::<Vec<_>>()
4754 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4755 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4756 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4757 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4758 msg = "instantiate this tuple variant";
4760 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4761 msg = "instantiate this tuple struct";
4766 Some(Node::ForeignItem(hir::ForeignItem {
4767 kind: hir::ForeignItemKind::Fn(_, idents, _),
4773 if ident.name != kw::SelfLower {
4779 .collect::<Vec<_>>()
4782 Some(Node::TraitItem(hir::TraitItem {
4783 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4789 if ident.name != kw::SelfLower {
4795 .collect::<Vec<_>>()
4800 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4801 err.span_suggestion(
4803 &format!("use parentheses to {}", msg),
4804 format!("{}({})", code, sugg_call),
4813 pub fn suggest_ref_or_into(
4815 err: &mut DiagnosticBuilder<'_>,
4816 expr: &hir::Expr<'_>,
4820 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4821 err.span_suggestion(sp, msg, suggestion, Applicability::MachineApplicable);
4822 } else if let (ty::FnDef(def_id, ..), true) =
4823 (&found.kind, self.suggest_fn_call(err, expr, expected, found))
4825 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4826 let sp = self.sess().source_map().def_span(sp);
4827 err.span_label(sp, &format!("{} defined here", found));
4829 } else if !self.check_for_cast(err, expr, found, expected) {
4830 let is_struct_pat_shorthand_field =
4831 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
4832 let methods = self.get_conversion_methods(expr.span, expected, found);
4833 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4834 let mut suggestions = iter::repeat(&expr_text)
4835 .zip(methods.iter())
4836 .filter_map(|(receiver, method)| {
4837 let method_call = format!(".{}()", method.ident);
4838 if receiver.ends_with(&method_call) {
4839 None // do not suggest code that is already there (#53348)
4841 let method_call_list = [".to_vec()", ".to_string()"];
4842 let sugg = if receiver.ends_with(".clone()")
4843 && method_call_list.contains(&method_call.as_str())
4845 let max_len = receiver.rfind(".").unwrap();
4846 format!("{}{}", &receiver[..max_len], method_call)
4848 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
4849 format!("({}){}", receiver, method_call)
4851 format!("{}{}", receiver, method_call)
4854 Some(if is_struct_pat_shorthand_field {
4855 format!("{}: {}", receiver, sugg)
4862 if suggestions.peek().is_some() {
4863 err.span_suggestions(
4865 "try using a conversion method",
4867 Applicability::MaybeIncorrect,
4874 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4875 /// in the heap by calling `Box::new()`.
4876 fn suggest_boxing_when_appropriate(
4878 err: &mut DiagnosticBuilder<'_>,
4879 expr: &hir::Expr<'_>,
4883 if self.tcx.hir().is_const_context(expr.hir_id) {
4884 // Do not suggest `Box::new` in const context.
4887 if !expected.is_box() || found.is_box() {
4890 let boxed_found = self.tcx.mk_box(found);
4891 if let (true, Ok(snippet)) = (
4892 self.can_coerce(boxed_found, expected),
4893 self.sess().source_map().span_to_snippet(expr.span),
4895 err.span_suggestion(
4897 "store this in the heap by calling `Box::new`",
4898 format!("Box::new({})", snippet),
4899 Applicability::MachineApplicable,
4902 "for more on the distinction between the stack and the \
4903 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4904 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4905 https://doc.rust-lang.org/std/boxed/index.html",
4910 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4914 /// bar_that_returns_u32()
4918 /// This routine checks if the return expression in a block would make sense on its own as a
4919 /// statement and the return type has been left as default or has been specified as `()`. If so,
4920 /// it suggests adding a semicolon.
4921 fn suggest_missing_semicolon(
4923 err: &mut DiagnosticBuilder<'_>,
4924 expression: &'tcx hir::Expr<'tcx>,
4928 if expected.is_unit() {
4929 // `BlockTailExpression` only relevant if the tail expr would be
4930 // useful on its own.
4931 match expression.kind {
4933 | ExprKind::MethodCall(..)
4934 | ExprKind::Loop(..)
4935 | ExprKind::Match(..)
4936 | ExprKind::Block(..) => {
4937 let sp = self.tcx.sess.source_map().next_point(cause_span);
4938 err.span_suggestion(
4940 "try adding a semicolon",
4942 Applicability::MachineApplicable,
4950 /// A possible error is to forget to add a return type that is needed:
4954 /// bar_that_returns_u32()
4958 /// This routine checks if the return type is left as default, the method is not part of an
4959 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4961 fn suggest_missing_return_type(
4963 err: &mut DiagnosticBuilder<'_>,
4964 fn_decl: &hir::FnDecl<'_>,
4969 // Only suggest changing the return type for methods that
4970 // haven't set a return type at all (and aren't `fn main()` or an impl).
4971 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4972 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4973 err.span_suggestion(
4975 "try adding a return type",
4976 format!("-> {} ", self.resolve_vars_with_obligations(found)),
4977 Applicability::MachineApplicable,
4981 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4982 err.span_label(span, "possibly return type missing here?");
4985 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4986 // `fn main()` must return `()`, do not suggest changing return type
4987 err.span_label(span, "expected `()` because of default return type");
4990 // expectation was caused by something else, not the default return
4991 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4992 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4993 // Only point to return type if the expected type is the return type, as if they
4994 // are not, the expectation must have been caused by something else.
4995 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
4997 let ty = AstConv::ast_ty_to_ty(self, ty);
4998 debug!("suggest_missing_return_type: return type {:?}", ty);
4999 debug!("suggest_missing_return_type: expected type {:?}", ty);
5000 if ty.kind == expected.kind {
5001 err.span_label(sp, format!("expected `{}` because of return type", expected));
5009 /// A possible error is to forget to add `.await` when using futures:
5012 /// async fn make_u32() -> u32 {
5016 /// fn take_u32(x: u32) {}
5018 /// async fn foo() {
5019 /// let x = make_u32();
5024 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
5025 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
5026 /// `.await` to the tail of the expression.
5027 fn suggest_missing_await(
5029 err: &mut DiagnosticBuilder<'_>,
5030 expr: &hir::Expr<'_>,
5034 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
5035 // body isn't `async`.
5036 let item_id = self.tcx().hir().get_parent_node(self.body_id);
5037 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
5038 let body = self.tcx().hir().body(body_id);
5039 if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
5041 // Check for `Future` implementations by constructing a predicate to
5042 // prove: `<T as Future>::Output == U`
5043 let future_trait = self.tcx.lang_items().future_trait().unwrap();
5044 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
5046 ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
5047 // `<T as Future>::Output`
5048 projection_ty: ty::ProjectionTy {
5050 substs: self.tcx.mk_substs_trait(
5052 self.fresh_substs_for_item(sp, item_def_id),
5059 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
5060 debug!("suggest_missing_await: trying obligation {:?}", obligation);
5061 if self.infcx.predicate_may_hold(&obligation) {
5062 debug!("suggest_missing_await: obligation held: {:?}", obligation);
5063 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
5064 err.span_suggestion(
5066 "consider using `.await` here",
5067 format!("{}.await", code),
5068 Applicability::MaybeIncorrect,
5071 debug!("suggest_missing_await: no snippet for {:?}", sp);
5074 debug!("suggest_missing_await: obligation did not hold: {:?}", obligation)
5080 /// A common error is to add an extra semicolon:
5083 /// fn foo() -> usize {
5088 /// This routine checks if the final statement in a block is an
5089 /// expression with an explicit semicolon whose type is compatible
5090 /// with `expected_ty`. If so, it suggests removing the semicolon.
5091 fn consider_hint_about_removing_semicolon(
5093 blk: &'tcx hir::Block<'tcx>,
5094 expected_ty: Ty<'tcx>,
5095 err: &mut DiagnosticBuilder<'_>,
5097 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
5098 err.span_suggestion(
5100 "consider removing this semicolon",
5102 Applicability::MachineApplicable,
5107 fn could_remove_semicolon(
5109 blk: &'tcx hir::Block<'tcx>,
5110 expected_ty: Ty<'tcx>,
5112 // Be helpful when the user wrote `{... expr;}` and
5113 // taking the `;` off is enough to fix the error.
5114 let last_stmt = blk.stmts.last()?;
5115 let last_expr = match last_stmt.kind {
5116 hir::StmtKind::Semi(ref e) => e,
5119 let last_expr_ty = self.node_ty(last_expr.hir_id);
5120 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
5123 let original_span = original_sp(last_stmt.span, blk.span);
5124 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
5127 // Instantiates the given path, which must refer to an item with the given
5128 // number of type parameters and type.
5129 pub fn instantiate_value_path(
5131 segments: &[hir::PathSegment<'_>],
5132 self_ty: Option<Ty<'tcx>>,
5136 ) -> (Ty<'tcx>, Res) {
5138 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
5139 segments, self_ty, res, hir_id,
5144 let path_segs = match res {
5145 Res::Local(_) | Res::SelfCtor(_) => vec![],
5146 Res::Def(kind, def_id) => {
5147 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id)
5149 _ => bug!("instantiate_value_path on {:?}", res),
5152 let mut user_self_ty = None;
5153 let mut is_alias_variant_ctor = false;
5155 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
5156 if let Some(self_ty) = self_ty {
5157 let adt_def = self_ty.ty_adt_def().unwrap();
5158 user_self_ty = Some(UserSelfTy { impl_def_id: adt_def.did, self_ty });
5159 is_alias_variant_ctor = true;
5162 Res::Def(DefKind::Method, def_id) | Res::Def(DefKind::AssocConst, def_id) => {
5163 let container = tcx.associated_item(def_id).container;
5164 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
5166 ty::TraitContainer(trait_did) => {
5167 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
5169 ty::ImplContainer(impl_def_id) => {
5170 if segments.len() == 1 {
5171 // `<T>::assoc` will end up here, and so
5172 // can `T::assoc`. It this came from an
5173 // inherent impl, we need to record the
5174 // `T` for posterity (see `UserSelfTy` for
5176 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
5177 user_self_ty = Some(UserSelfTy { impl_def_id, self_ty });
5185 // Now that we have categorized what space the parameters for each
5186 // segment belong to, let's sort out the parameters that the user
5187 // provided (if any) into their appropriate spaces. We'll also report
5188 // errors if type parameters are provided in an inappropriate place.
5190 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
5191 let generics_has_err = AstConv::prohibit_generics(
5193 segments.iter().enumerate().filter_map(|(index, seg)| {
5194 if !generic_segs.contains(&index) || is_alias_variant_ctor {
5202 if let Res::Local(hid) = res {
5203 let ty = self.local_ty(span, hid).decl_ty;
5204 let ty = self.normalize_associated_types_in(span, &ty);
5205 self.write_ty(hir_id, ty);
5209 if generics_has_err {
5210 // Don't try to infer type parameters when prohibited generic arguments were given.
5211 user_self_ty = None;
5214 // Now we have to compare the types that the user *actually*
5215 // provided against the types that were *expected*. If the user
5216 // did not provide any types, then we want to substitute inference
5217 // variables. If the user provided some types, we may still need
5218 // to add defaults. If the user provided *too many* types, that's
5221 let mut infer_args_for_err = FxHashSet::default();
5222 for &PathSeg(def_id, index) in &path_segs {
5223 let seg = &segments[index];
5224 let generics = tcx.generics_of(def_id);
5225 // Argument-position `impl Trait` is treated as a normal generic
5226 // parameter internally, but we don't allow users to specify the
5227 // parameter's value explicitly, so we have to do some error-
5229 let suppress_errors = AstConv::check_generic_arg_count_for_call(
5230 tcx, span, &generics, &seg, false, // `is_method_call`
5232 if suppress_errors {
5233 infer_args_for_err.insert(index);
5234 self.set_tainted_by_errors(); // See issue #53251.
5238 let has_self = path_segs
5240 .map(|PathSeg(def_id, _)| tcx.generics_of(*def_id).has_self)
5243 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
5244 let ty = self.impl_self_ty(span, impl_def_id).ty;
5245 let adt_def = ty.ty_adt_def();
5248 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
5249 let variant = adt_def.non_enum_variant();
5250 let ctor_def_id = variant.ctor_def_id.unwrap();
5252 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
5257 let mut err = tcx.sess.struct_span_err(
5259 "the `Self` constructor can only be used with tuple or unit structs",
5261 if let Some(adt_def) = adt_def {
5262 match adt_def.adt_kind() {
5264 err.help("did you mean to use one of the enum's variants?");
5266 AdtKind::Struct | AdtKind::Union => {
5267 err.span_suggestion(
5269 "use curly brackets",
5270 String::from("Self { /* fields */ }"),
5271 Applicability::HasPlaceholders,
5278 return (tcx.types.err, res);
5284 let def_id = res.def_id();
5286 // The things we are substituting into the type should not contain
5287 // escaping late-bound regions, and nor should the base type scheme.
5288 let ty = tcx.type_of(def_id);
5290 let substs = self_ctor_substs.unwrap_or_else(|| {
5291 AstConv::create_substs_for_generic_args(
5297 // Provide the generic args, and whether types should be inferred.
5299 if let Some(&PathSeg(_, index)) =
5300 path_segs.iter().find(|&PathSeg(did, _)| *did == def_id)
5302 // If we've encountered an `impl Trait`-related error, we're just
5303 // going to infer the arguments for better error messages.
5304 if !infer_args_for_err.contains(&index) {
5305 // Check whether the user has provided generic arguments.
5306 if let Some(ref data) = segments[index].args {
5307 return (Some(data), segments[index].infer_args);
5310 return (None, segments[index].infer_args);
5315 // Provide substitutions for parameters for which (valid) arguments have been provided.
5316 |param, arg| match (¶m.kind, arg) {
5317 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
5318 AstConv::ast_region_to_region(self, lt, Some(param)).into()
5320 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
5321 self.to_ty(ty).into()
5323 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
5324 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
5326 _ => unreachable!(),
5328 // Provide substitutions for parameters for which arguments are inferred.
5329 |substs, param, infer_args| {
5331 GenericParamDefKind::Lifetime => {
5332 self.re_infer(Some(param), span).unwrap().into()
5334 GenericParamDefKind::Type { has_default, .. } => {
5335 if !infer_args && has_default {
5336 // If we have a default, then we it doesn't matter that we're not
5337 // inferring the type arguments: we provide the default where any
5339 let default = tcx.type_of(param.def_id);
5342 default.subst_spanned(tcx, substs.unwrap(), Some(span)),
5346 // If no type arguments were provided, we have to infer them.
5347 // This case also occurs as a result of some malformed input, e.g.
5348 // a lifetime argument being given instead of a type parameter.
5349 // Using inference instead of `Error` gives better error messages.
5350 self.var_for_def(span, param)
5353 GenericParamDefKind::Const => {
5354 // FIXME(const_generics:defaults)
5355 // No const parameters were provided, we have to infer them.
5356 self.var_for_def(span, param)
5362 assert!(!substs.has_escaping_bound_vars());
5363 assert!(!ty.has_escaping_bound_vars());
5365 // First, store the "user substs" for later.
5366 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
5368 self.add_required_obligations(span, def_id, &substs);
5370 // Substitute the values for the type parameters into the type of
5371 // the referenced item.
5372 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
5374 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
5375 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
5376 // is inherent, there is no `Self` parameter; instead, the impl needs
5377 // type parameters, which we can infer by unifying the provided `Self`
5378 // with the substituted impl type.
5379 // This also occurs for an enum variant on a type alias.
5380 let ty = tcx.type_of(impl_def_id);
5382 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
5383 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
5384 Ok(ok) => self.register_infer_ok_obligations(ok),
5386 self.tcx.sess.delay_span_bug(span, &format!(
5387 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
5395 self.check_rustc_args_require_const(def_id, hir_id, span);
5397 debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_substituted);
5398 self.write_substs(hir_id, substs);
5400 (ty_substituted, res)
5403 /// Add all the obligations that are required, substituting and normalized appropriately.
5404 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
5405 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
5407 for (i, mut obligation) in traits::predicates_for_generics(
5408 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
5415 // This makes the error point at the bound, but we want to point at the argument
5416 if let Some(span) = spans.get(i) {
5417 obligation.cause.code = traits::BindingObligation(def_id, *span);
5419 self.register_predicate(obligation);
5423 fn check_rustc_args_require_const(&self, def_id: DefId, hir_id: hir::HirId, span: Span) {
5424 // We're only interested in functions tagged with
5425 // #[rustc_args_required_const], so ignore anything that's not.
5426 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
5430 // If our calling expression is indeed the function itself, we're good!
5431 // If not, generate an error that this can only be called directly.
5432 if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(hir_id)) {
5433 if let ExprKind::Call(ref callee, ..) = expr.kind {
5434 if callee.hir_id == hir_id {
5440 self.tcx.sess.span_err(
5442 "this function can only be invoked \
5443 directly, not through a function pointer",
5447 /// Resolves `typ` by a single level if `typ` is a type variable.
5448 /// If no resolution is possible, then an error is reported.
5449 /// Numeric inference variables may be left unresolved.
5450 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
5451 let ty = self.resolve_vars_with_obligations(ty);
5452 if !ty.is_ty_var() {
5455 if !self.is_tainted_by_errors() {
5456 self.need_type_info_err((**self).body_id, sp, ty, E0282)
5457 .note("type must be known at this point")
5460 self.demand_suptype(sp, self.tcx.types.err, ty);
5465 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
5468 ctxt: BreakableCtxt<'tcx>,
5470 ) -> (BreakableCtxt<'tcx>, R) {
5473 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5474 index = enclosing_breakables.stack.len();
5475 enclosing_breakables.by_id.insert(id, index);
5476 enclosing_breakables.stack.push(ctxt);
5480 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
5481 debug_assert!(enclosing_breakables.stack.len() == index + 1);
5482 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
5483 enclosing_breakables.stack.pop().expect("missing breakable context")
5488 /// Instantiate a QueryResponse in a probe context, without a
5489 /// good ObligationCause.
5490 fn probe_instantiate_query_response(
5493 original_values: &OriginalQueryValues<'tcx>,
5494 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
5495 ) -> InferResult<'tcx, Ty<'tcx>> {
5496 self.instantiate_query_response_and_region_obligations(
5497 &traits::ObligationCause::misc(span, self.body_id),
5504 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
5505 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5506 let mut contained_in_place = false;
5508 while let hir::Node::Expr(parent_expr) =
5509 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5511 match &parent_expr.kind {
5512 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5513 if lhs.hir_id == expr_id {
5514 contained_in_place = true;
5520 expr_id = parent_expr.hir_id;
5527 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5528 let own_counts = generics.own_counts();
5530 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5531 own_counts.types, own_counts.consts, ty
5534 if own_counts.types == 0 {
5538 // Make a vector of booleans initially `false`; set to `true` when used.
5539 let mut types_used = vec![false; own_counts.types];
5541 for leaf_ty in ty.walk() {
5542 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5543 debug!("found use of ty param num {}", index);
5544 types_used[index as usize - own_counts.lifetimes] = true;
5545 } else if let ty::Error = leaf_ty.kind {
5546 // If there is already another error, do not emit
5547 // an error for not using a type parameter.
5548 assert!(tcx.sess.has_errors());
5553 let types = generics.params.iter().filter(|param| match param.kind {
5554 ty::GenericParamDefKind::Type { .. } => true,
5557 for (&used, param) in types_used.iter().zip(types) {
5559 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5560 let span = tcx.hir().span(id);
5561 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5562 .span_label(span, "unused type parameter")
5568 fn fatally_break_rust(sess: &Session) {
5569 let handler = sess.diagnostic();
5570 handler.span_bug_no_panic(
5572 "It looks like you're trying to break rust; would you like some ICE?",
5574 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5575 handler.note_without_error(
5576 "we would appreciate a joke overview: \
5577 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675",
5579 handler.note_without_error(&format!(
5580 "rustc {} running on {}",
5581 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5582 crate::session::config::host_triple(),
5586 fn potentially_plural_count(count: usize, word: &str) -> String {
5587 format!("{} {}{}", count, word, pluralize!(count))