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
86 mod generator_interior;
90 use crate::astconv::{AstConv, PathSeg};
91 use errors::{Applicability, DiagnosticBuilder, DiagnosticId, pluralise};
92 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
93 use rustc::hir::def::{CtorOf, Res, DefKind};
94 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
95 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
96 use rustc::hir::itemlikevisit::ItemLikeVisitor;
97 use rustc::hir::ptr::P;
98 use crate::middle::lang_items;
99 use crate::namespace::Namespace;
100 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
101 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
102 use rustc_index::vec::Idx;
103 use rustc_target::spec::abi::Abi;
104 use rustc::infer::opaque_types::OpaqueTypeDecl;
105 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
106 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
107 use rustc::middle::region;
108 use rustc::mir::interpret::{ConstValue, GlobalId};
109 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
111 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
112 ToPolyTraitRef, ToPredicate, RegionKind, UserType
114 use rustc::ty::adjustment::{
115 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
117 use rustc::ty::fold::TypeFoldable;
118 use rustc::ty::query::Providers;
119 use rustc::ty::subst::{
120 GenericArgKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts,
122 use rustc::ty::util::{Representability, IntTypeExt, Discr};
123 use rustc::ty::layout::VariantIdx;
124 use syntax_pos::{self, BytePos, Span, MultiSpan};
125 use syntax_pos::hygiene::DesugaringKind;
128 use syntax::feature_gate::{GateIssue, emit_feature_err};
129 use syntax::source_map::{DUMMY_SP, original_sp};
130 use syntax::symbol::{kw, sym};
132 use std::cell::{Cell, RefCell, Ref, RefMut};
133 use std::collections::hash_map::Entry;
136 use std::mem::replace;
137 use std::ops::{self, Deref};
140 use crate::require_c_abi_if_c_variadic;
141 use crate::session::Session;
142 use crate::session::config::EntryFnType;
143 use crate::TypeAndSubsts;
145 use crate::util::captures::Captures;
146 use crate::util::common::{ErrorReported, indenter};
147 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
149 pub use self::Expectation::*;
150 use self::autoderef::Autoderef;
151 use self::callee::DeferredCallResolution;
152 use self::coercion::{CoerceMany, DynamicCoerceMany};
153 pub use self::compare_method::{compare_impl_method, compare_const_impl};
154 use self::method::{MethodCallee, SelfSource};
155 use self::TupleArgumentsFlag::*;
157 /// The type of a local binding, including the revealed type for anon types.
158 #[derive(Copy, Clone, Debug)]
159 pub struct LocalTy<'tcx> {
161 revealed_ty: Ty<'tcx>
164 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
165 #[derive(Copy, Clone)]
166 struct MaybeInProgressTables<'a, 'tcx> {
167 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
170 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
171 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
172 match self.maybe_tables {
173 Some(tables) => tables.borrow(),
175 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(),
184 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
190 /// Closures defined within the function. For example:
193 /// bar(move|| { ... })
196 /// Here, the function `foo()` and the closure passed to
197 /// `bar()` will each have their own `FnCtxt`, but they will
198 /// share the inherited fields.
199 pub struct Inherited<'a, 'tcx> {
200 infcx: InferCtxt<'a, 'tcx>,
202 tables: MaybeInProgressTables<'a, 'tcx>,
204 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
206 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
208 // Some additional `Sized` obligations badly affect type inference.
209 // These obligations are added in a later stage of typeck.
210 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
212 // When we process a call like `c()` where `c` is a closure type,
213 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
214 // `FnOnce` closure. In that case, we defer full resolution of the
215 // call until upvar inference can kick in and make the
216 // decision. We keep these deferred resolutions grouped by the
217 // def-id of the closure, so that once we decide, we can easily go
218 // back and process them.
219 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
221 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
223 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
225 // Opaque types found in explicit return types and their
226 // associated fresh inference variable. Writeback resolves these
227 // variables to get the concrete type, which can be used to
228 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
229 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
231 /// Each type parameter has an implicit region bound that
232 /// indicates it must outlive at least the function body (the user
233 /// may specify stronger requirements). This field indicates the
234 /// region of the callee. If it is `None`, then the parameter
235 /// environment is for an item or something where the "callee" is
237 implicit_region_bound: Option<ty::Region<'tcx>>,
239 body_id: Option<hir::BodyId>,
242 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
243 type Target = InferCtxt<'a, 'tcx>;
244 fn deref(&self) -> &Self::Target {
249 /// When type-checking an expression, we propagate downward
250 /// whatever type hint we are able in the form of an `Expectation`.
251 #[derive(Copy, Clone, Debug)]
252 pub enum Expectation<'tcx> {
253 /// We know nothing about what type this expression should have.
256 /// This expression should have the type given (or some subtype).
257 ExpectHasType(Ty<'tcx>),
259 /// This expression will be cast to the `Ty`.
260 ExpectCastableToType(Ty<'tcx>),
262 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
263 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
264 ExpectRvalueLikeUnsized(Ty<'tcx>),
267 impl<'a, 'tcx> Expectation<'tcx> {
268 // Disregard "castable to" expectations because they
269 // can lead us astray. Consider for example `if cond
270 // {22} else {c} as u8` -- if we propagate the
271 // "castable to u8" constraint to 22, it will pick the
272 // type 22u8, which is overly constrained (c might not
273 // be a u8). In effect, the problem is that the
274 // "castable to" expectation is not the tightest thing
275 // we can say, so we want to drop it in this case.
276 // The tightest thing we can say is "must unify with
277 // else branch". Note that in the case of a "has type"
278 // constraint, this limitation does not hold.
280 // If the expected type is just a type variable, then don't use
281 // an expected type. Otherwise, we might write parts of the type
282 // when checking the 'then' block which are incompatible with the
284 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
286 ExpectHasType(ety) => {
287 let ety = fcx.shallow_resolve(ety);
288 if !ety.is_ty_var() {
294 ExpectRvalueLikeUnsized(ety) => {
295 ExpectRvalueLikeUnsized(ety)
301 /// Provides an expectation for an rvalue expression given an *optional*
302 /// hint, which is not required for type safety (the resulting type might
303 /// be checked higher up, as is the case with `&expr` and `box expr`), but
304 /// is useful in determining the concrete type.
306 /// The primary use case is where the expected type is a fat pointer,
307 /// like `&[isize]`. For example, consider the following statement:
309 /// let x: &[isize] = &[1, 2, 3];
311 /// In this case, the expected type for the `&[1, 2, 3]` expression is
312 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
313 /// expectation `ExpectHasType([isize])`, that would be too strong --
314 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
315 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
316 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
317 /// which still is useful, because it informs integer literals and the like.
318 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
319 /// for examples of where this comes up,.
320 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
321 match fcx.tcx.struct_tail_without_normalization(ty).kind {
322 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
323 ExpectRvalueLikeUnsized(ty)
325 _ => ExpectHasType(ty)
329 // Resolves `expected` by a single level if it is a variable. If
330 // there is no expected type or resolution is not possible (e.g.,
331 // no constraints yet present), just returns `None`.
332 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
334 NoExpectation => NoExpectation,
335 ExpectCastableToType(t) => {
336 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
338 ExpectHasType(t) => {
339 ExpectHasType(fcx.resolve_vars_if_possible(&t))
341 ExpectRvalueLikeUnsized(t) => {
342 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
347 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
348 match self.resolve(fcx) {
349 NoExpectation => None,
350 ExpectCastableToType(ty) |
352 ExpectRvalueLikeUnsized(ty) => Some(ty),
356 /// It sometimes happens that we want to turn an expectation into
357 /// a **hard constraint** (i.e., something that must be satisfied
358 /// for the program to type-check). `only_has_type` will return
359 /// such a constraint, if it exists.
360 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
361 match self.resolve(fcx) {
362 ExpectHasType(ty) => Some(ty),
363 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
367 /// Like `only_has_type`, but instead of returning `None` if no
368 /// hard constraint exists, creates a fresh type variable.
369 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
370 self.only_has_type(fcx)
372 fcx.next_ty_var(TypeVariableOrigin {
373 kind: TypeVariableOriginKind::MiscVariable,
380 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
387 fn maybe_mut_place(m: hir::Mutability) -> Self {
389 hir::MutMutable => Needs::MutPlace,
390 hir::MutImmutable => Needs::None,
395 #[derive(Copy, Clone)]
396 pub struct UnsafetyState {
398 pub unsafety: hir::Unsafety,
399 pub unsafe_push_count: u32,
404 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
405 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
408 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
409 match self.unsafety {
410 // If this unsafe, then if the outer function was already marked as
411 // unsafe we shouldn't attribute the unsafe'ness to the block. This
412 // way the block can be warned about instead of ignoring this
413 // extraneous block (functions are never warned about).
414 hir::Unsafety::Unsafe if self.from_fn => *self,
417 let (unsafety, def, count) = match blk.rules {
418 hir::PushUnsafeBlock(..) =>
419 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
420 hir::PopUnsafeBlock(..) =>
421 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
422 hir::UnsafeBlock(..) =>
423 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
425 (unsafety, self.def, self.unsafe_push_count),
429 unsafe_push_count: count,
436 #[derive(Debug, Copy, Clone)]
442 /// Tracks whether executing a node may exit normally (versus
443 /// return/break/panic, which "diverge", leaving dead code in their
444 /// wake). Tracked semi-automatically (through type variables marked
445 /// as diverging), with some manual adjustments for control-flow
446 /// primitives (approximating a CFG).
447 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
449 /// Potentially unknown, some cases converge,
450 /// others require a CFG to determine them.
453 /// Definitely known to diverge and therefore
454 /// not reach the next sibling or its parent.
456 /// The `Span` points to the expression
457 /// that caused us to diverge
458 /// (e.g. `return`, `break`, etc).
460 /// In some cases (e.g. a `match` expression
461 /// where all arms diverge), we may be
462 /// able to provide a more informative
463 /// message to the user.
464 /// If this is `None`, a default messsage
465 /// will be generated, which is suitable
467 custom_note: Option<&'static str>
470 /// Same as `Always` but with a reachability
471 /// warning already emitted.
475 // Convenience impls for combinig `Diverges`.
477 impl ops::BitAnd for Diverges {
479 fn bitand(self, other: Self) -> Self {
480 cmp::min(self, other)
484 impl ops::BitOr for Diverges {
486 fn bitor(self, other: Self) -> Self {
487 cmp::max(self, other)
491 impl ops::BitAndAssign for Diverges {
492 fn bitand_assign(&mut self, other: Self) {
493 *self = *self & other;
497 impl ops::BitOrAssign for Diverges {
498 fn bitor_assign(&mut self, other: Self) {
499 *self = *self | other;
504 /// Creates a `Diverges::Always` with the provided `span` and the default note message.
505 fn always(span: Span) -> Diverges {
512 fn is_always(self) -> bool {
513 // Enum comparison ignores the
514 // contents of fields, so we just
515 // fill them in with garbage here.
516 self >= Diverges::Always {
523 pub struct BreakableCtxt<'tcx> {
526 // this is `null` for loops where break with a value is illegal,
527 // such as `while`, `for`, and `while let`
528 coerce: Option<DynamicCoerceMany<'tcx>>,
531 pub struct EnclosingBreakables<'tcx> {
532 stack: Vec<BreakableCtxt<'tcx>>,
533 by_id: HirIdMap<usize>,
536 impl<'tcx> EnclosingBreakables<'tcx> {
537 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
538 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
539 bug!("could not find enclosing breakable with id {}", target_id);
545 pub struct FnCtxt<'a, 'tcx> {
548 /// The parameter environment used for proving trait obligations
549 /// in this function. This can change when we descend into
550 /// closures (as they bring new things into scope), hence it is
551 /// not part of `Inherited` (as of the time of this writing,
552 /// closures do not yet change the environment, but they will
554 param_env: ty::ParamEnv<'tcx>,
556 /// Number of errors that had been reported when we started
557 /// checking this function. On exit, if we find that *more* errors
558 /// have been reported, we will skip regionck and other work that
559 /// expects the types within the function to be consistent.
560 // FIXME(matthewjasper) This should not exist, and it's not correct
561 // if type checking is run in parallel.
562 err_count_on_creation: usize,
564 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
565 ret_coercion_span: RefCell<Option<Span>>,
567 yield_ty: Option<Ty<'tcx>>,
569 ps: RefCell<UnsafetyState>,
571 /// Whether the last checked node generates a divergence (e.g.,
572 /// `return` will set this to `Always`). In general, when entering
573 /// an expression or other node in the tree, the initial value
574 /// indicates whether prior parts of the containing expression may
575 /// have diverged. It is then typically set to `Maybe` (and the
576 /// old value remembered) for processing the subparts of the
577 /// current expression. As each subpart is processed, they may set
578 /// the flag to `Always`, etc. Finally, at the end, we take the
579 /// result and "union" it with the original value, so that when we
580 /// return the flag indicates if any subpart of the parent
581 /// expression (up to and including this part) has diverged. So,
582 /// if you read it after evaluating a subexpression `X`, the value
583 /// you get indicates whether any subexpression that was
584 /// evaluating up to and including `X` diverged.
586 /// We currently use this flag only for diagnostic purposes:
588 /// - To warn about unreachable code: if, after processing a
589 /// sub-expression but before we have applied the effects of the
590 /// current node, we see that the flag is set to `Always`, we
591 /// can issue a warning. This corresponds to something like
592 /// `foo(return)`; we warn on the `foo()` expression. (We then
593 /// update the flag to `WarnedAlways` to suppress duplicate
594 /// reports.) Similarly, if we traverse to a fresh statement (or
595 /// tail expression) from a `Always` setting, we will issue a
596 /// warning. This corresponds to something like `{return;
597 /// foo();}` or `{return; 22}`, where we would warn on the
600 /// An expression represents dead code if, after checking it,
601 /// the diverges flag is set to something other than `Maybe`.
602 diverges: Cell<Diverges>,
604 /// Whether any child nodes have any type errors.
605 has_errors: Cell<bool>,
607 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
609 inh: &'a Inherited<'a, 'tcx>,
612 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
613 type Target = Inherited<'a, 'tcx>;
614 fn deref(&self) -> &Self::Target {
619 /// Helper type of a temporary returned by `Inherited::build(...)`.
620 /// Necessary because we can't write the following bound:
621 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
622 pub struct InheritedBuilder<'tcx> {
623 infcx: infer::InferCtxtBuilder<'tcx>,
627 impl Inherited<'_, 'tcx> {
628 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
629 let hir_id_root = if def_id.is_local() {
630 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
631 DefId::local(hir_id.owner)
637 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
643 impl<'tcx> InheritedBuilder<'tcx> {
644 fn enter<F, R>(&mut self, f: F) -> R
646 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
648 let def_id = self.def_id;
649 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
653 impl Inherited<'a, 'tcx> {
654 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
656 let item_id = tcx.hir().as_local_hir_id(def_id);
657 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
658 let implicit_region_bound = body_id.map(|body_id| {
659 let body = tcx.hir().body(body_id);
660 tcx.mk_region(ty::ReScope(region::Scope {
661 id: body.value.hir_id.local_id,
662 data: region::ScopeData::CallSite
667 tables: MaybeInProgressTables {
668 maybe_tables: infcx.in_progress_tables,
671 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
672 locals: RefCell::new(Default::default()),
673 deferred_sized_obligations: RefCell::new(Vec::new()),
674 deferred_call_resolutions: RefCell::new(Default::default()),
675 deferred_cast_checks: RefCell::new(Vec::new()),
676 deferred_generator_interiors: RefCell::new(Vec::new()),
677 opaque_types: RefCell::new(Default::default()),
678 implicit_region_bound,
683 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
684 debug!("register_predicate({:?})", obligation);
685 if obligation.has_escaping_bound_vars() {
686 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
691 .register_predicate_obligation(self, obligation);
694 fn register_predicates<I>(&self, obligations: I)
695 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
697 for obligation in obligations {
698 self.register_predicate(obligation);
702 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
703 self.register_predicates(infer_ok.obligations);
707 fn normalize_associated_types_in<T>(&self,
710 param_env: ty::ParamEnv<'tcx>,
712 where T : TypeFoldable<'tcx>
714 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
715 self.register_infer_ok_obligations(ok)
719 struct CheckItemTypesVisitor<'tcx> {
723 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
724 fn visit_item(&mut self, i: &'tcx hir::Item) {
725 check_item_type(self.tcx, i);
727 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
728 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
731 pub fn check_wf_new(tcx: TyCtxt<'_>) {
732 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
733 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
736 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
737 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
740 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
741 debug_assert!(crate_num == LOCAL_CRATE);
742 tcx.par_body_owners(|body_owner_def_id| {
743 tcx.ensure().typeck_tables_of(body_owner_def_id);
747 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
748 wfcheck::check_item_well_formed(tcx, def_id);
751 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
752 wfcheck::check_trait_item(tcx, def_id);
755 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
756 wfcheck::check_impl_item(tcx, def_id);
759 pub fn provide(providers: &mut Providers<'_>) {
760 method::provide(providers);
761 *providers = Providers {
767 check_item_well_formed,
768 check_trait_item_well_formed,
769 check_impl_item_well_formed,
770 check_mod_item_types,
775 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
776 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
779 /// If this `DefId` is a "primary tables entry", returns
780 /// `Some((body_id, header, decl))` with information about
781 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
784 /// If this function returns `Some`, then `typeck_tables(def_id)` will
785 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
786 /// may not succeed. In some cases where this function returns `None`
787 /// (notably closures), `typeck_tables(def_id)` would wind up
788 /// redirecting to the owning function.
792 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
793 match tcx.hir().get(id) {
794 Node::Item(item) => {
796 hir::ItemKind::Const(ref ty, body) |
797 hir::ItemKind::Static(ref ty, _, body) =>
798 Some((body, Some(ty), None, None)),
799 hir::ItemKind::Fn(ref decl, ref header, .., body) =>
800 Some((body, None, Some(header), Some(decl))),
805 Node::TraitItem(item) => {
807 hir::TraitItemKind::Const(ref ty, Some(body)) =>
808 Some((body, Some(ty), None, None)),
809 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
810 Some((body, None, Some(&sig.header), Some(&sig.decl))),
815 Node::ImplItem(item) => {
817 hir::ImplItemKind::Const(ref ty, body) =>
818 Some((body, Some(ty), None, None)),
819 hir::ImplItemKind::Method(ref sig, body) =>
820 Some((body, None, Some(&sig.header), Some(&sig.decl))),
825 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
830 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
831 // Closures' tables come from their outermost function,
832 // as they are part of the same "inference environment".
833 let outer_def_id = tcx.closure_base_def_id(def_id);
834 if outer_def_id != def_id {
835 return tcx.has_typeck_tables(outer_def_id);
838 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
839 primary_body_of(tcx, id).is_some()
842 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
843 &*tcx.typeck_tables_of(def_id).used_trait_imports
846 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
847 // Closures' tables come from their outermost function,
848 // as they are part of the same "inference environment".
849 let outer_def_id = tcx.closure_base_def_id(def_id);
850 if outer_def_id != def_id {
851 return tcx.typeck_tables_of(outer_def_id);
854 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
855 let span = tcx.hir().span(id);
857 // Figure out what primary body this item has.
858 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
860 span_bug!(span, "can't type-check body of {:?}", def_id);
862 let body = tcx.hir().body(body_id);
864 let tables = Inherited::build(tcx, def_id).enter(|inh| {
865 let param_env = tcx.param_env(def_id);
866 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
867 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
868 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
869 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
874 check_abi(tcx, span, fn_sig.abi());
876 // Compute the fty from point of view of inside the fn.
878 tcx.liberate_late_bound_regions(def_id, &fn_sig);
880 inh.normalize_associated_types_in(body.value.span,
885 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
888 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
889 let expected_type = body_ty.and_then(|ty| match ty.kind {
890 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
892 }).unwrap_or_else(|| tcx.type_of(def_id));
893 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
894 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
896 let revealed_ty = if tcx.features().impl_trait_in_bindings {
897 fcx.instantiate_opaque_types_from_value(
906 // Gather locals in statics (because of block expressions).
907 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
909 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
911 fcx.write_ty(id, revealed_ty);
916 // All type checking constraints were added, try to fallback unsolved variables.
917 fcx.select_obligations_where_possible(false, |_| {});
918 let mut fallback_has_occurred = false;
919 for ty in &fcx.unsolved_variables() {
920 fallback_has_occurred |= fcx.fallback_if_possible(ty);
922 fcx.select_obligations_where_possible(fallback_has_occurred, |_| {});
924 // Even though coercion casts provide type hints, we check casts after fallback for
925 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
928 // Closure and generator analysis may run after fallback
929 // because they don't constrain other type variables.
930 fcx.closure_analyze(body);
931 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
932 fcx.resolve_generator_interiors(def_id);
934 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
935 let ty = fcx.normalize_ty(span, ty);
936 fcx.require_type_is_sized(ty, span, code);
938 fcx.select_all_obligations_or_error();
940 if fn_decl.is_some() {
941 fcx.regionck_fn(id, body);
943 fcx.regionck_expr(body);
946 fcx.resolve_type_vars_in_body(body)
949 // Consistency check our TypeckTables instance can hold all ItemLocalIds
950 // it will need to hold.
951 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
956 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
957 if !tcx.sess.target.target.is_abi_supported(abi) {
958 struct_span_err!(tcx.sess, span, E0570,
959 "The ABI `{}` is not supported for the current target", abi).emit()
963 struct GatherLocalsVisitor<'a, 'tcx> {
964 fcx: &'a FnCtxt<'a, 'tcx>,
965 parent_id: hir::HirId,
968 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
969 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
972 // infer the variable's type
973 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
974 kind: TypeVariableOriginKind::TypeInference,
977 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
984 // take type that the user specified
985 self.fcx.locals.borrow_mut().insert(nid, typ);
992 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
993 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
994 NestedVisitorMap::None
997 // Add explicitly-declared locals.
998 fn visit_local(&mut self, local: &'tcx hir::Local) {
999 let local_ty = match local.ty {
1001 let o_ty = self.fcx.to_ty(&ty);
1003 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
1004 self.fcx.instantiate_opaque_types_from_value(
1013 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
1014 &UserType::Ty(revealed_ty)
1016 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1017 ty.hir_id, o_ty, revealed_ty, c_ty);
1018 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1020 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1024 self.assign(local.span, local.hir_id, local_ty);
1026 debug!("local variable {:?} is assigned type {}",
1028 self.fcx.ty_to_string(
1029 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1030 intravisit::walk_local(self, local);
1033 // Add pattern bindings.
1034 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1035 if let PatKind::Binding(_, _, ident, _) = p.kind {
1036 let var_ty = self.assign(p.span, p.hir_id, None);
1038 if !self.fcx.tcx.features().unsized_locals {
1039 self.fcx.require_type_is_sized(var_ty, p.span,
1040 traits::VariableType(p.hir_id));
1043 debug!("pattern binding {} is assigned to {} with type {:?}",
1045 self.fcx.ty_to_string(
1046 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1049 intravisit::walk_pat(self, p);
1052 // Don't descend into the bodies of nested closures
1055 _: intravisit::FnKind<'tcx>,
1056 _: &'tcx hir::FnDecl,
1063 /// When `check_fn` is invoked on a generator (i.e., a body that
1064 /// includes yield), it returns back some information about the yield
1066 struct GeneratorTypes<'tcx> {
1067 /// Type of value that is yielded.
1070 /// Types that are captured (see `GeneratorInterior` for more).
1073 /// Indicates if the generator is movable or static (immovable).
1074 movability: hir::GeneratorMovability,
1077 /// Helper used for fns and closures. Does the grungy work of checking a function
1078 /// body and returns the function context used for that purpose, since in the case of a fn item
1079 /// there is still a bit more to do.
1082 /// * inherited: other fields inherited from the enclosing fn (if any)
1083 fn check_fn<'a, 'tcx>(
1084 inherited: &'a Inherited<'a, 'tcx>,
1085 param_env: ty::ParamEnv<'tcx>,
1086 fn_sig: ty::FnSig<'tcx>,
1087 decl: &'tcx hir::FnDecl,
1089 body: &'tcx hir::Body,
1090 can_be_generator: Option<hir::GeneratorMovability>,
1091 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1092 let mut fn_sig = fn_sig.clone();
1094 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1096 // Create the function context. This is either derived from scratch or,
1097 // in the case of closures, based on the outer context.
1098 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1099 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1101 let declared_ret_ty = fn_sig.output();
1102 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1103 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1108 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1109 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1110 fn_sig = fcx.tcx.mk_fn_sig(
1111 fn_sig.inputs().iter().cloned(),
1118 let span = body.value.span;
1120 fn_maybe_err(fcx.tcx, span, fn_sig.abi);
1122 if body.generator_kind.is_some() && can_be_generator.is_some() {
1123 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1124 kind: TypeVariableOriginKind::TypeInference,
1127 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1128 fcx.yield_ty = Some(yield_ty);
1131 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1132 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1133 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1135 // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
1136 // (as it's created inside the body itself, not passed in from outside).
1137 let maybe_va_list = if fn_sig.c_variadic {
1138 let va_list_did = fcx.tcx.require_lang_item(
1139 lang_items::VaListTypeLangItem,
1140 Some(body.params.last().unwrap().span),
1142 let region = fcx.tcx.mk_region(ty::ReScope(region::Scope {
1143 id: body.value.hir_id.local_id,
1144 data: region::ScopeData::CallSite
1147 Some(fcx.tcx.type_of(va_list_did).subst(fcx.tcx, &[region.into()]))
1152 // Add formal parameters.
1153 for (param_ty, param) in
1154 fn_sig.inputs().iter().copied()
1155 .chain(maybe_va_list)
1158 // Check the pattern.
1159 fcx.check_pat_top(¶m.pat, param_ty, None);
1161 // Check that argument is Sized.
1162 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1163 // for simple cases like `fn foo(x: Trait)`,
1164 // where we would error once on the parameter as a whole, and once on the binding `x`.
1165 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1166 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1169 fcx.write_ty(param.hir_id, param_ty);
1172 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1174 fcx.check_return_expr(&body.value);
1176 // We insert the deferred_generator_interiors entry after visiting the body.
1177 // This ensures that all nested generators appear before the entry of this generator.
1178 // resolve_generator_interiors relies on this property.
1179 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1180 let interior = fcx.next_ty_var(TypeVariableOrigin {
1181 kind: TypeVariableOriginKind::MiscVariable,
1184 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1185 Some(GeneratorTypes {
1186 yield_ty: fcx.yield_ty.unwrap(),
1188 movability: can_be_generator.unwrap(),
1194 // Finalize the return check by taking the LUB of the return types
1195 // we saw and assigning it to the expected return type. This isn't
1196 // really expected to fail, since the coercions would have failed
1197 // earlier when trying to find a LUB.
1199 // However, the behavior around `!` is sort of complex. In the
1200 // event that the `actual_return_ty` comes back as `!`, that
1201 // indicates that the fn either does not return or "returns" only
1202 // values of type `!`. In this case, if there is an expected
1203 // return type that is *not* `!`, that should be ok. But if the
1204 // return type is being inferred, we want to "fallback" to `!`:
1206 // let x = move || panic!();
1208 // To allow for that, I am creating a type variable with diverging
1209 // fallback. This was deemed ever so slightly better than unifying
1210 // the return value with `!` because it allows for the caller to
1211 // make more assumptions about the return type (e.g., they could do
1213 // let y: Option<u32> = Some(x());
1215 // which would then cause this return type to become `u32`, not
1217 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1218 let mut actual_return_ty = coercion.complete(&fcx);
1219 if actual_return_ty.is_never() {
1220 actual_return_ty = fcx.next_diverging_ty_var(
1221 TypeVariableOrigin {
1222 kind: TypeVariableOriginKind::DivergingFn,
1227 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1229 // Check that the main return type implements the termination trait.
1230 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1231 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1232 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1233 if main_id == fn_id {
1234 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1235 let trait_ref = ty::TraitRef::new(term_id, substs);
1236 let return_ty_span = decl.output.span();
1237 let cause = traits::ObligationCause::new(
1238 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1240 inherited.register_predicate(
1241 traits::Obligation::new(
1242 cause, param_env, trait_ref.to_predicate()));
1247 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1248 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1249 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1250 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1251 // at this point we don't care if there are duplicate handlers or if the handler has
1252 // the wrong signature as this value we'll be used when writing metadata and that
1253 // only happens if compilation succeeded
1254 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1256 if declared_ret_ty.kind != ty::Never {
1257 fcx.tcx.sess.span_err(
1259 "return type should be `!`",
1263 let inputs = fn_sig.inputs();
1264 let span = fcx.tcx.hir().span(fn_id);
1265 if inputs.len() == 1 {
1266 let arg_is_panic_info = match inputs[0].kind {
1267 ty::Ref(region, ty, mutbl) => match ty.kind {
1268 ty::Adt(ref adt, _) => {
1269 adt.did == panic_info_did &&
1270 mutbl == hir::Mutability::MutImmutable &&
1271 *region != RegionKind::ReStatic
1278 if !arg_is_panic_info {
1279 fcx.tcx.sess.span_err(
1280 decl.inputs[0].span,
1281 "argument should be `&PanicInfo`",
1285 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1286 if let ItemKind::Fn(_, _, ref generics, _) = item.kind {
1287 if !generics.params.is_empty() {
1288 fcx.tcx.sess.span_err(
1290 "should have no type parameters",
1296 let span = fcx.tcx.sess.source_map().def_span(span);
1297 fcx.tcx.sess.span_err(span, "function should have one argument");
1300 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1305 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1306 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1307 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1308 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1309 if declared_ret_ty.kind != ty::Never {
1310 fcx.tcx.sess.span_err(
1312 "return type should be `!`",
1316 let inputs = fn_sig.inputs();
1317 let span = fcx.tcx.hir().span(fn_id);
1318 if inputs.len() == 1 {
1319 let arg_is_alloc_layout = match inputs[0].kind {
1320 ty::Adt(ref adt, _) => {
1321 adt.did == alloc_layout_did
1326 if !arg_is_alloc_layout {
1327 fcx.tcx.sess.span_err(
1328 decl.inputs[0].span,
1329 "argument should be `Layout`",
1333 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1334 if let ItemKind::Fn(_, _, ref generics, _) = item.kind {
1335 if !generics.params.is_empty() {
1336 fcx.tcx.sess.span_err(
1338 "`#[alloc_error_handler]` function should have no type \
1345 let span = fcx.tcx.sess.source_map().def_span(span);
1346 fcx.tcx.sess.span_err(span, "function should have one argument");
1349 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1357 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1358 let def_id = tcx.hir().local_def_id(id);
1359 let def = tcx.adt_def(def_id);
1360 def.destructor(tcx); // force the destructor to be evaluated
1361 check_representable(tcx, span, def_id);
1363 if def.repr.simd() {
1364 check_simd(tcx, span, def_id);
1367 check_transparent(tcx, span, def_id);
1368 check_packed(tcx, span, def_id);
1371 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1372 let def_id = tcx.hir().local_def_id(id);
1373 let def = tcx.adt_def(def_id);
1374 def.destructor(tcx); // force the destructor to be evaluated
1375 check_representable(tcx, span, def_id);
1376 check_transparent(tcx, span, def_id);
1377 check_packed(tcx, span, def_id);
1380 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1381 /// projections that would result in "inheriting lifetimes".
1382 fn check_opaque<'tcx>(
1385 substs: SubstsRef<'tcx>,
1387 origin: &hir::OpaqueTyOrigin,
1389 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1390 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1393 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1394 /// in "inheriting lifetimes".
1395 fn check_opaque_for_inheriting_lifetimes(
1400 let item = tcx.hir().expect_item(
1401 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1402 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1403 def_id, span, item);
1406 struct ProhibitOpaqueVisitor<'tcx> {
1407 opaque_identity_ty: Ty<'tcx>,
1408 generics: &'tcx ty::Generics,
1411 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1412 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1413 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1414 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1417 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1418 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1419 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1420 return *index < self.generics.parent_count as u32;
1423 r.super_visit_with(self)
1427 let prohibit_opaque = match item.kind {
1428 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1429 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1430 let mut visitor = ProhibitOpaqueVisitor {
1431 opaque_identity_ty: tcx.mk_opaque(
1432 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1433 generics: tcx.generics_of(def_id),
1435 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1437 tcx.predicates_of(def_id).predicates.iter().any(
1438 |(predicate, _)| predicate.visit_with(&mut visitor))
1443 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1444 if prohibit_opaque {
1445 let is_async = match item.kind {
1446 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1447 hir::OpaqueTyOrigin::AsyncFn => true,
1450 _ => unreachable!(),
1453 tcx.sess.span_err(span, &format!(
1454 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1456 if is_async { "async fn" } else { "impl Trait" },
1461 /// Checks that an opaque type does not contain cycles.
1462 fn check_opaque_for_cycles<'tcx>(
1465 substs: SubstsRef<'tcx>,
1467 origin: &hir::OpaqueTyOrigin,
1469 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1470 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1472 tcx.sess, span, E0733,
1473 "recursion in an `async fn` requires boxing",
1475 .span_label(span, "recursive `async fn`")
1476 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1479 let mut err = struct_span_err!(
1480 tcx.sess, span, E0720,
1481 "opaque type expands to a recursive type",
1483 err.span_label(span, "expands to a recursive type");
1484 if let ty::Opaque(..) = partially_expanded_type.kind {
1485 err.note("type resolves to itself");
1487 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1494 // Forbid defining intrinsics in Rust code,
1495 // as they must always be defined by the compiler.
1496 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1497 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1498 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1502 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1504 "check_item_type(it.hir_id={}, it.name={})",
1506 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1508 let _indenter = indenter();
1510 // Consts can play a role in type-checking, so they are included here.
1511 hir::ItemKind::Static(..) => {
1512 let def_id = tcx.hir().local_def_id(it.hir_id);
1513 tcx.typeck_tables_of(def_id);
1514 maybe_check_static_with_link_section(tcx, def_id, it.span);
1516 hir::ItemKind::Const(..) => {
1517 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1519 hir::ItemKind::Enum(ref enum_definition, _) => {
1520 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1522 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1523 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1524 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1525 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1526 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1527 check_impl_items_against_trait(
1534 let trait_def_id = impl_trait_ref.def_id;
1535 check_on_unimplemented(tcx, trait_def_id, it);
1538 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1539 let def_id = tcx.hir().local_def_id(it.hir_id);
1540 check_on_unimplemented(tcx, def_id, it);
1542 for item in items.iter() {
1543 let item = tcx.hir().trait_item(item.id);
1544 if let hir::TraitItemKind::Method(sig, _) = &item.kind {
1545 let abi = sig.header.abi;
1546 fn_maybe_err(tcx, item.ident.span, abi);
1550 hir::ItemKind::Struct(..) => {
1551 check_struct(tcx, it.hir_id, it.span);
1553 hir::ItemKind::Union(..) => {
1554 check_union(tcx, it.hir_id, it.span);
1556 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1557 let def_id = tcx.hir().local_def_id(it.hir_id);
1559 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1560 check_opaque(tcx, def_id, substs, it.span, &origin);
1562 hir::ItemKind::TyAlias(..) => {
1563 let def_id = tcx.hir().local_def_id(it.hir_id);
1564 let pty_ty = tcx.type_of(def_id);
1565 let generics = tcx.generics_of(def_id);
1566 check_bounds_are_used(tcx, &generics, pty_ty);
1568 hir::ItemKind::ForeignMod(ref m) => {
1569 check_abi(tcx, it.span, m.abi);
1571 if m.abi == Abi::RustIntrinsic {
1572 for item in &m.items {
1573 intrinsic::check_intrinsic_type(tcx, item);
1575 } else if m.abi == Abi::PlatformIntrinsic {
1576 for item in &m.items {
1577 intrinsic::check_platform_intrinsic_type(tcx, item);
1580 for item in &m.items {
1581 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1582 let own_counts = generics.own_counts();
1583 if generics.params.len() - own_counts.lifetimes != 0 {
1584 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1585 (_, 0) => ("type", "types", Some("u32")),
1586 // We don't specify an example value, because we can't generate
1587 // a valid value for any type.
1588 (0, _) => ("const", "consts", None),
1589 _ => ("type or const", "types or consts", None),
1595 "foreign items may not have {} parameters",
1599 &format!("can't have {} parameters", kinds),
1601 // FIXME: once we start storing spans for type arguments, turn this
1602 // into a suggestion.
1604 "replace the {} parameters with concrete {}{}",
1607 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1612 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.kind {
1613 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1618 _ => { /* nothing to do */ }
1622 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1623 // Only restricted on wasm32 target for now
1624 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1628 // If `#[link_section]` is missing, then nothing to verify
1629 let attrs = tcx.codegen_fn_attrs(id);
1630 if attrs.link_section.is_none() {
1634 // For the wasm32 target statics with `#[link_section]` are placed into custom
1635 // sections of the final output file, but this isn't link custom sections of
1636 // other executable formats. Namely we can only embed a list of bytes,
1637 // nothing with pointers to anything else or relocations. If any relocation
1638 // show up, reject them here.
1639 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1640 // the consumer's responsibility to ensure all bytes that have been read
1641 // have defined values.
1642 let instance = ty::Instance::mono(tcx, id);
1643 let cid = GlobalId {
1647 let param_env = ty::ParamEnv::reveal_all();
1648 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1649 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1652 bug!("Matching on non-ByRef static")
1654 if alloc.relocations().len() != 0 {
1655 let msg = "statics with a custom `#[link_section]` must be a \
1656 simple list of bytes on the wasm target with no \
1657 extra levels of indirection such as references";
1658 tcx.sess.span_err(span, msg);
1663 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1664 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1665 // an error would be reported if this fails.
1666 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1669 fn report_forbidden_specialization(
1671 impl_item: &hir::ImplItem,
1674 let mut err = struct_span_err!(
1675 tcx.sess, impl_item.span, E0520,
1676 "`{}` specializes an item from a parent `impl`, but \
1677 that item is not marked `default`",
1679 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1682 match tcx.span_of_impl(parent_impl) {
1684 err.span_label(span, "parent `impl` is here");
1685 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1689 err.note(&format!("parent implementation is in crate `{}`", cname));
1696 fn check_specialization_validity<'tcx>(
1698 trait_def: &ty::TraitDef,
1699 trait_item: &ty::AssocItem,
1701 impl_item: &hir::ImplItem,
1703 let ancestors = trait_def.ancestors(tcx, impl_id);
1705 let kind = match impl_item.kind {
1706 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1707 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1708 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1709 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1712 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1713 .map(|node_item| node_item.map(|parent| parent.defaultness));
1715 if let Some(parent) = parent {
1716 if tcx.impl_item_is_final(&parent) {
1717 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1723 fn check_impl_items_against_trait<'tcx>(
1727 impl_trait_ref: ty::TraitRef<'tcx>,
1728 impl_item_refs: &[hir::ImplItemRef],
1730 let impl_span = tcx.sess.source_map().def_span(impl_span);
1732 // If the trait reference itself is erroneous (so the compilation is going
1733 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1734 // isn't populated for such impls.
1735 if impl_trait_ref.references_error() { return; }
1737 // Locate trait definition and items
1738 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1739 let mut overridden_associated_type = None;
1741 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1743 // Check existing impl methods to see if they are both present in trait
1744 // and compatible with trait signature
1745 for impl_item in impl_items() {
1746 let ty_impl_item = tcx.associated_item(
1747 tcx.hir().local_def_id(impl_item.hir_id));
1748 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1749 .find(|ac| Namespace::from(&impl_item.kind) == Namespace::from(ac.kind) &&
1750 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1752 // Not compatible, but needed for the error message
1753 tcx.associated_items(impl_trait_ref.def_id)
1754 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1757 // Check that impl definition matches trait definition
1758 if let Some(ty_trait_item) = ty_trait_item {
1759 match impl_item.kind {
1760 hir::ImplItemKind::Const(..) => {
1761 // Find associated const definition.
1762 if ty_trait_item.kind == ty::AssocKind::Const {
1763 compare_const_impl(tcx,
1769 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1770 "item `{}` is an associated const, \
1771 which doesn't match its trait `{}`",
1774 err.span_label(impl_item.span, "does not match trait");
1775 // We can only get the spans from local trait definition
1776 // Same for E0324 and E0325
1777 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1778 err.span_label(trait_span, "item in trait");
1783 hir::ImplItemKind::Method(..) => {
1784 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1785 if ty_trait_item.kind == ty::AssocKind::Method {
1786 compare_impl_method(tcx,
1793 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1794 "item `{}` is an associated method, \
1795 which doesn't match its trait `{}`",
1798 err.span_label(impl_item.span, "does not match trait");
1799 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1800 err.span_label(trait_span, "item in trait");
1805 hir::ImplItemKind::OpaqueTy(..) |
1806 hir::ImplItemKind::TyAlias(_) => {
1807 if ty_trait_item.kind == ty::AssocKind::Type {
1808 if ty_trait_item.defaultness.has_value() {
1809 overridden_associated_type = Some(impl_item);
1812 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1813 "item `{}` is an associated type, \
1814 which doesn't match its trait `{}`",
1817 err.span_label(impl_item.span, "does not match trait");
1818 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1819 err.span_label(trait_span, "item in trait");
1826 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1830 // Check for missing items from trait
1831 let mut missing_items = Vec::new();
1832 let mut invalidated_items = Vec::new();
1833 let associated_type_overridden = overridden_associated_type.is_some();
1834 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1835 let is_implemented = trait_def.ancestors(tcx, impl_id)
1836 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1838 .map(|node_item| !node_item.node.is_from_trait())
1841 if !is_implemented && !tcx.impl_is_default(impl_id) {
1842 if !trait_item.defaultness.has_value() {
1843 missing_items.push(trait_item);
1844 } else if associated_type_overridden {
1845 invalidated_items.push(trait_item.ident);
1850 if !missing_items.is_empty() {
1851 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1852 "not all trait items implemented, missing: `{}`",
1853 missing_items.iter()
1854 .map(|trait_item| trait_item.ident.to_string())
1855 .collect::<Vec<_>>().join("`, `"));
1856 err.span_label(impl_span, format!("missing `{}` in implementation",
1857 missing_items.iter()
1858 .map(|trait_item| trait_item.ident.to_string())
1859 .collect::<Vec<_>>().join("`, `")));
1860 for trait_item in missing_items {
1861 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1862 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1864 err.note_trait_signature(trait_item.ident.to_string(),
1865 trait_item.signature(tcx));
1871 if !invalidated_items.is_empty() {
1872 let invalidator = overridden_associated_type.unwrap();
1873 span_err!(tcx.sess, invalidator.span, E0399,
1874 "the following trait items need to be reimplemented \
1875 as `{}` was overridden: `{}`",
1877 invalidated_items.iter()
1878 .map(|name| name.to_string())
1879 .collect::<Vec<_>>().join("`, `"))
1883 /// Checks whether a type can be represented in memory. In particular, it
1884 /// identifies types that contain themselves without indirection through a
1885 /// pointer, which would mean their size is unbounded.
1886 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1887 let rty = tcx.type_of(item_def_id);
1889 // Check that it is possible to represent this type. This call identifies
1890 // (1) types that contain themselves and (2) types that contain a different
1891 // recursive type. It is only necessary to throw an error on those that
1892 // contain themselves. For case 2, there must be an inner type that will be
1893 // caught by case 1.
1894 match rty.is_representable(tcx, sp) {
1895 Representability::SelfRecursive(spans) => {
1896 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1898 err.span_label(span, "recursive without indirection");
1903 Representability::Representable | Representability::ContainsRecursive => (),
1908 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1909 let t = tcx.type_of(def_id);
1910 if let ty::Adt(def, substs) = t.kind {
1911 if def.is_struct() {
1912 let fields = &def.non_enum_variant().fields;
1913 if fields.is_empty() {
1914 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1917 let e = fields[0].ty(tcx, substs);
1918 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1919 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1920 .span_label(sp, "SIMD elements must have the same type")
1925 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1926 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1928 span_err!(tcx.sess, sp, E0077,
1929 "SIMD vector element type should be machine type");
1937 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1938 let repr = tcx.adt_def(def_id).repr;
1940 for attr in tcx.get_attrs(def_id).iter() {
1941 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1942 if let attr::ReprPacked(pack) = r {
1943 if let Some(repr_pack) = repr.pack {
1944 if pack as u64 != repr_pack.bytes() {
1946 tcx.sess, sp, E0634,
1947 "type has conflicting packed representation hints"
1954 if repr.align.is_some() {
1955 struct_span_err!(tcx.sess, sp, E0587,
1956 "type has conflicting packed and align representation hints").emit();
1958 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1959 struct_span_err!(tcx.sess, sp, E0588,
1960 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1965 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1966 let t = tcx.type_of(def_id);
1967 if stack.contains(&def_id) {
1968 debug!("check_packed_inner: {:?} is recursive", t);
1971 if let ty::Adt(def, substs) = t.kind {
1972 if def.is_struct() || def.is_union() {
1973 if tcx.adt_def(def.did).repr.align.is_some() {
1976 // push struct def_id before checking fields
1978 for field in &def.non_enum_variant().fields {
1979 let f = field.ty(tcx, substs);
1980 if let ty::Adt(def, _) = f.kind {
1981 if check_packed_inner(tcx, def.did, stack) {
1986 // only need to pop if not early out
1993 /// Emit an error when encountering more or less than one variant in a transparent enum.
1994 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1995 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1996 tcx.hir().span_if_local(variant.def_id).unwrap()
1999 "needs exactly one variant, but has {}",
2002 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
2003 err.span_label(sp, &msg);
2004 if let &[ref start @ .., ref end] = &variant_spans[..] {
2005 for variant_span in start {
2006 err.span_label(*variant_span, "");
2008 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
2013 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
2015 fn bad_non_zero_sized_fields<'tcx>(
2017 adt: &'tcx ty::AdtDef,
2019 field_spans: impl Iterator<Item = Span>,
2022 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
2023 let mut err = struct_span_err!(
2027 "{}transparent {} {}",
2028 if adt.is_enum() { "the variant of a " } else { "" },
2032 err.span_label(sp, &msg);
2033 for sp in field_spans {
2034 err.span_label(sp, "this field is non-zero-sized");
2039 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2040 let adt = tcx.adt_def(def_id);
2041 if !adt.repr.transparent() {
2044 let sp = tcx.sess.source_map().def_span(sp);
2047 if !tcx.features().transparent_enums {
2049 &tcx.sess.parse_sess,
2050 sym::transparent_enums,
2052 GateIssue::Language,
2053 "transparent enums are unstable",
2056 if adt.variants.len() != 1 {
2057 bad_variant_count(tcx, adt, sp, def_id);
2058 if adt.variants.is_empty() {
2059 // Don't bother checking the fields. No variants (and thus no fields) exist.
2065 if adt.is_union() && !tcx.features().transparent_unions {
2066 emit_feature_err(&tcx.sess.parse_sess,
2067 sym::transparent_unions,
2069 GateIssue::Language,
2070 "transparent unions are unstable");
2073 // For each field, figure out if it's known to be a ZST and align(1)
2074 let field_infos = adt.all_fields().map(|field| {
2075 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2076 let param_env = tcx.param_env(field.did);
2077 let layout = tcx.layout_of(param_env.and(ty));
2078 // We are currently checking the type this field came from, so it must be local
2079 let span = tcx.hir().span_if_local(field.did).unwrap();
2080 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2081 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2085 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2090 let non_zst_count = non_zst_fields.clone().count();
2091 if non_zst_count != 1 {
2092 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2094 for (span, zst, align1) in field_infos {
2100 "zero-sized field in transparent {} has alignment larger than 1",
2102 ).span_label(span, "has alignment larger than 1").emit();
2107 #[allow(trivial_numeric_casts)]
2108 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
2109 let def_id = tcx.hir().local_def_id(id);
2110 let def = tcx.adt_def(def_id);
2111 def.destructor(tcx); // force the destructor to be evaluated
2114 let attributes = tcx.get_attrs(def_id);
2115 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2117 tcx.sess, attr.span, E0084,
2118 "unsupported representation for zero-variant enum")
2119 .span_label(sp, "zero-variant enum")
2124 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2125 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2126 if !tcx.features().repr128 {
2127 emit_feature_err(&tcx.sess.parse_sess,
2130 GateIssue::Language,
2131 "repr with 128-bit type is unstable");
2136 if let Some(ref e) = v.disr_expr {
2137 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2141 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2143 |var: &hir::Variant| match var.data {
2144 hir::VariantData::Unit(..) => true,
2148 let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
2149 let has_non_units = vs.iter().any(|var| !is_unit(var));
2150 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2151 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2153 if disr_non_unit || (disr_units && has_non_units) {
2154 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2155 "`#[repr(inttype)]` must be specified");
2160 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2161 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2162 // Check for duplicate discriminant values
2163 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2164 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2165 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2166 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2167 let i_span = match variant_i.disr_expr {
2168 Some(ref expr) => tcx.hir().span(expr.hir_id),
2169 None => tcx.hir().span(variant_i_hir_id)
2171 let span = match v.disr_expr {
2172 Some(ref expr) => tcx.hir().span(expr.hir_id),
2175 struct_span_err!(tcx.sess, span, E0081,
2176 "discriminant value `{}` already exists", disr_vals[i])
2177 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2178 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2181 disr_vals.push(discr);
2184 check_representable(tcx, sp, def_id);
2185 check_transparent(tcx, sp, def_id);
2188 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2189 span_err!(tcx.sess, span, E0533,
2190 "expected unit struct/variant or constant, found {} `{}`",
2192 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2195 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2196 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2200 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2201 -> &'tcx ty::GenericPredicates<'tcx>
2204 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2205 let item_id = tcx.hir().ty_param_owner(hir_id);
2206 let item_def_id = tcx.hir().local_def_id(item_id);
2207 let generics = tcx.generics_of(item_def_id);
2208 let index = generics.param_def_id_to_index[&def_id];
2209 tcx.arena.alloc(ty::GenericPredicates {
2211 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2213 ty::Predicate::Trait(ref data)
2214 if data.skip_binder().self_ty().is_param(index) => {
2215 // HACK(eddyb) should get the original `Span`.
2216 let span = tcx.def_span(def_id);
2217 Some((predicate, span))
2227 def: Option<&ty::GenericParamDef>,
2229 ) -> Option<ty::Region<'tcx>> {
2231 Some(def) => infer::EarlyBoundRegion(span, def.name),
2232 None => infer::MiscVariable(span)
2234 Some(self.next_region_var(v))
2237 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2238 if let Some(param) = param {
2239 if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
2244 self.next_ty_var(TypeVariableOrigin {
2245 kind: TypeVariableOriginKind::TypeInference,
2254 param: Option<&ty::GenericParamDef>,
2256 ) -> &'tcx Const<'tcx> {
2257 if let Some(param) = param {
2258 if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
2263 self.next_const_var(ty, ConstVariableOrigin {
2264 kind: ConstVariableOriginKind::ConstInference,
2270 fn projected_ty_from_poly_trait_ref(&self,
2273 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2276 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2278 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2282 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2285 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2286 if ty.has_escaping_bound_vars() {
2287 ty // FIXME: normalization and escaping regions
2289 self.normalize_associated_types_in(span, &ty)
2293 fn set_tainted_by_errors(&self) {
2294 self.infcx.set_tainted_by_errors()
2297 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2298 self.write_ty(hir_id, ty)
2302 /// Controls whether the arguments are tupled. This is used for the call
2305 /// Tupling means that all call-side arguments are packed into a tuple and
2306 /// passed as a single parameter. For example, if tupling is enabled, this
2309 /// fn f(x: (isize, isize))
2311 /// Can be called as:
2318 #[derive(Clone, Eq, PartialEq)]
2319 enum TupleArgumentsFlag {
2324 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2326 inh: &'a Inherited<'a, 'tcx>,
2327 param_env: ty::ParamEnv<'tcx>,
2328 body_id: hir::HirId,
2329 ) -> FnCtxt<'a, 'tcx> {
2333 err_count_on_creation: inh.tcx.sess.err_count(),
2335 ret_coercion_span: RefCell::new(None),
2337 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2338 hir::CRATE_HIR_ID)),
2339 diverges: Cell::new(Diverges::Maybe),
2340 has_errors: Cell::new(false),
2341 enclosing_breakables: RefCell::new(EnclosingBreakables {
2343 by_id: Default::default(),
2349 pub fn sess(&self) -> &Session {
2353 pub fn errors_reported_since_creation(&self) -> bool {
2354 self.tcx.sess.err_count() > self.err_count_on_creation
2357 /// Produces warning on the given node, if the current point in the
2358 /// function is unreachable, and there hasn't been another warning.
2359 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2360 // FIXME: Combine these two 'if' expressions into one once
2361 // let chains are implemented
2362 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2363 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2364 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2365 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2366 if !span.is_desugaring(DesugaringKind::CondTemporary) &&
2367 !span.is_desugaring(DesugaringKind::Async) &&
2368 !orig_span.is_desugaring(DesugaringKind::Await)
2370 self.diverges.set(Diverges::WarnedAlways);
2372 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2374 let msg = format!("unreachable {}", kind);
2375 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2376 .span_label(span, &msg)
2379 custom_note.unwrap_or("any code following this expression is unreachable"),
2388 code: ObligationCauseCode<'tcx>)
2389 -> ObligationCause<'tcx> {
2390 ObligationCause::new(span, self.body_id, code)
2393 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2394 self.cause(span, ObligationCauseCode::MiscObligation)
2397 /// Resolves type variables in `ty` if possible. Unlike the infcx
2398 /// version (resolve_vars_if_possible), this version will
2399 /// also select obligations if it seems useful, in an effort
2400 /// to get more type information.
2401 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2402 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2404 // No Infer()? Nothing needs doing.
2405 if !ty.has_infer_types() {
2406 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2410 // If `ty` is a type variable, see whether we already know what it is.
2411 ty = self.resolve_vars_if_possible(&ty);
2412 if !ty.has_infer_types() {
2413 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2417 // If not, try resolving pending obligations as much as
2418 // possible. This can help substantially when there are
2419 // indirect dependencies that don't seem worth tracking
2421 self.select_obligations_where_possible(false, |_| {});
2422 ty = self.resolve_vars_if_possible(&ty);
2424 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2428 fn record_deferred_call_resolution(
2430 closure_def_id: DefId,
2431 r: DeferredCallResolution<'tcx>,
2433 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2434 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2437 fn remove_deferred_call_resolutions(
2439 closure_def_id: DefId,
2440 ) -> Vec<DeferredCallResolution<'tcx>> {
2441 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2442 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2445 pub fn tag(&self) -> String {
2446 format!("{:p}", self)
2449 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2450 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2451 span_bug!(span, "no type for local variable {}",
2452 self.tcx.hir().node_to_string(nid))
2457 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2458 debug!("write_ty({:?}, {:?}) in fcx {}",
2459 id, self.resolve_vars_if_possible(&ty), self.tag());
2460 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2462 if ty.references_error() {
2463 self.has_errors.set(true);
2464 self.set_tainted_by_errors();
2468 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2469 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2472 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2473 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2476 pub fn write_method_call(&self,
2478 method: MethodCallee<'tcx>) {
2479 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2480 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2481 self.write_substs(hir_id, method.substs);
2483 // When the method is confirmed, the `method.substs` includes
2484 // parameters from not just the method, but also the impl of
2485 // the method -- in particular, the `Self` type will be fully
2486 // resolved. However, those are not something that the "user
2487 // specified" -- i.e., those types come from the inferred type
2488 // of the receiver, not something the user wrote. So when we
2489 // create the user-substs, we want to replace those earlier
2490 // types with just the types that the user actually wrote --
2491 // that is, those that appear on the *method itself*.
2493 // As an example, if the user wrote something like
2494 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2495 // type of `foo` (possibly adjusted), but we don't want to
2496 // include that. We want just the `[_, u32]` part.
2497 if !method.substs.is_noop() {
2498 let method_generics = self.tcx.generics_of(method.def_id);
2499 if !method_generics.params.is_empty() {
2500 let user_type_annotation = self.infcx.probe(|_| {
2501 let user_substs = UserSubsts {
2502 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2503 let i = param.index as usize;
2504 if i < method_generics.parent_count {
2505 self.infcx.var_for_def(DUMMY_SP, param)
2510 user_self_ty: None, // not relevant here
2513 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2519 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2520 self.write_user_type_annotation(hir_id, user_type_annotation);
2525 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2526 if !substs.is_noop() {
2527 debug!("write_substs({:?}, {:?}) in fcx {}",
2532 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2536 /// Given the substs that we just converted from the HIR, try to
2537 /// canonicalize them and store them as user-given substitutions
2538 /// (i.e., substitutions that must be respected by the NLL check).
2540 /// This should be invoked **before any unifications have
2541 /// occurred**, so that annotations like `Vec<_>` are preserved
2543 pub fn write_user_type_annotation_from_substs(
2547 substs: SubstsRef<'tcx>,
2548 user_self_ty: Option<UserSelfTy<'tcx>>,
2551 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2552 user_self_ty={:?} in fcx {}",
2553 hir_id, def_id, substs, user_self_ty, self.tag(),
2556 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2557 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2558 &UserType::TypeOf(def_id, UserSubsts {
2563 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2564 self.write_user_type_annotation(hir_id, canonicalized);
2568 pub fn write_user_type_annotation(
2571 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2574 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2575 hir_id, canonical_user_type_annotation, self.tag(),
2578 if !canonical_user_type_annotation.is_identity() {
2579 self.tables.borrow_mut().user_provided_types_mut().insert(
2580 hir_id, canonical_user_type_annotation
2583 debug!("write_user_type_annotation: skipping identity substs");
2587 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2588 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2594 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2595 Entry::Vacant(entry) => { entry.insert(adj); },
2596 Entry::Occupied(mut entry) => {
2597 debug!(" - composing on top of {:?}", entry.get());
2598 match (&entry.get()[..], &adj[..]) {
2599 // Applying any adjustment on top of a NeverToAny
2600 // is a valid NeverToAny adjustment, because it can't
2602 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2604 Adjustment { kind: Adjust::Deref(_), .. },
2605 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2607 Adjustment { kind: Adjust::Deref(_), .. },
2608 .. // Any following adjustments are allowed.
2610 // A reborrow has no effect before a dereference.
2612 // FIXME: currently we never try to compose autoderefs
2613 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2615 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2616 expr, entry.get(), adj)
2618 *entry.get_mut() = adj;
2623 /// Basically whenever we are converting from a type scheme into
2624 /// the fn body space, we always want to normalize associated
2625 /// types as well. This function combines the two.
2626 fn instantiate_type_scheme<T>(&self,
2628 substs: SubstsRef<'tcx>,
2631 where T : TypeFoldable<'tcx>
2633 let value = value.subst(self.tcx, substs);
2634 let result = self.normalize_associated_types_in(span, &value);
2635 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2642 /// As `instantiate_type_scheme`, but for the bounds found in a
2643 /// generic type scheme.
2644 fn instantiate_bounds(
2648 substs: SubstsRef<'tcx>,
2649 ) -> (ty::InstantiatedPredicates<'tcx>, Vec<Span>) {
2650 let bounds = self.tcx.predicates_of(def_id);
2651 let spans: Vec<Span> = bounds.predicates.iter().map(|(_, span)| *span).collect();
2652 let result = bounds.instantiate(self.tcx, substs);
2653 let result = self.normalize_associated_types_in(span, &result);
2655 "instantiate_bounds(bounds={:?}, substs={:?}) = {:?}, {:?}",
2664 /// Replaces the opaque types from the given value with type variables,
2665 /// and records the `OpaqueTypeMap` for later use during writeback. See
2666 /// `InferCtxt::instantiate_opaque_types` for more details.
2667 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2669 parent_id: hir::HirId,
2673 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2674 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2678 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2679 self.instantiate_opaque_types(
2688 let mut opaque_types = self.opaque_types.borrow_mut();
2689 for (ty, decl) in opaque_type_map {
2690 let old_value = opaque_types.insert(ty, decl);
2691 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2697 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2698 where T : TypeFoldable<'tcx>
2700 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2703 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2705 where T : TypeFoldable<'tcx>
2707 self.inh.partially_normalize_associated_types_in(span,
2713 pub fn require_type_meets(&self,
2716 code: traits::ObligationCauseCode<'tcx>,
2719 self.register_bound(
2722 traits::ObligationCause::new(span, self.body_id, code));
2725 pub fn require_type_is_sized(
2729 code: traits::ObligationCauseCode<'tcx>,
2731 if !ty.references_error() {
2732 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
2733 self.require_type_meets(ty, span, code, lang_item);
2737 pub fn require_type_is_sized_deferred(
2741 code: traits::ObligationCauseCode<'tcx>,
2743 if !ty.references_error() {
2744 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2748 pub fn register_bound(
2752 cause: traits::ObligationCause<'tcx>,
2754 if !ty.references_error() {
2755 self.fulfillment_cx.borrow_mut()
2756 .register_bound(self, self.param_env, ty, def_id, cause);
2760 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2761 let t = AstConv::ast_ty_to_ty(self, ast_t);
2762 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2766 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2767 let ty = self.to_ty(ast_ty);
2768 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2770 if Self::can_contain_user_lifetime_bounds(ty) {
2771 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2772 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2773 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2779 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2780 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2781 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2784 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2785 AstConv::ast_const_to_const(self, ast_c, ty)
2788 // If the type given by the user has free regions, save it for later, since
2789 // NLL would like to enforce those. Also pass in types that involve
2790 // projections, since those can resolve to `'static` bounds (modulo #54940,
2791 // which hopefully will be fixed by the time you see this comment, dear
2792 // reader, although I have my doubts). Also pass in types with inference
2793 // types, because they may be repeated. Other sorts of things are already
2794 // sufficiently enforced with erased regions. =)
2795 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2797 T: TypeFoldable<'tcx>
2799 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2802 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2803 match self.tables.borrow().node_types().get(id) {
2805 None if self.is_tainted_by_errors() => self.tcx.types.err,
2807 bug!("no type for node {}: {} in fcx {}",
2808 id, self.tcx.hir().node_to_string(id),
2814 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2815 /// outlive the region `r`.
2816 pub fn register_wf_obligation(
2820 code: traits::ObligationCauseCode<'tcx>,
2822 // WF obligations never themselves fail, so no real need to give a detailed cause:
2823 let cause = traits::ObligationCause::new(span, self.body_id, code);
2824 self.register_predicate(
2825 traits::Obligation::new(cause, self.param_env, ty::Predicate::WellFormed(ty)),
2829 /// Registers obligations that all types appearing in `substs` are well-formed.
2830 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2831 for ty in substs.types() {
2832 if !ty.references_error() {
2833 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2838 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2839 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2840 /// trait/region obligations.
2842 /// For example, if there is a function:
2845 /// fn foo<'a,T:'a>(...)
2848 /// and a reference:
2854 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2855 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2856 pub fn add_obligations_for_parameters(&self,
2857 cause: traits::ObligationCause<'tcx>,
2858 predicates: &ty::InstantiatedPredicates<'tcx>)
2860 assert!(!predicates.has_escaping_bound_vars());
2862 debug!("add_obligations_for_parameters(predicates={:?})",
2865 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2866 self.register_predicate(obligation);
2870 // FIXME(arielb1): use this instead of field.ty everywhere
2871 // Only for fields! Returns <none> for methods>
2872 // Indifferent to privacy flags
2876 field: &'tcx ty::FieldDef,
2877 substs: SubstsRef<'tcx>,
2879 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2882 fn check_casts(&self) {
2883 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2884 for cast in deferred_cast_checks.drain(..) {
2889 fn resolve_generator_interiors(&self, def_id: DefId) {
2890 let mut generators = self.deferred_generator_interiors.borrow_mut();
2891 for (body_id, interior, kind) in generators.drain(..) {
2892 self.select_obligations_where_possible(false, |_| {});
2893 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2897 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2898 // Non-numerics get replaced with ! or () (depending on whether
2899 // feature(never_type) is enabled, unconstrained ints with i32,
2900 // unconstrained floats with f64.
2901 // Fallback becomes very dubious if we have encountered type-checking errors.
2902 // In that case, fallback to Error.
2903 // The return value indicates whether fallback has occurred.
2904 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2905 use rustc::ty::error::UnconstrainedNumeric::Neither;
2906 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2908 assert!(ty.is_ty_infer());
2909 let fallback = match self.type_is_unconstrained_numeric(ty) {
2910 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2911 UnconstrainedInt => self.tcx.types.i32,
2912 UnconstrainedFloat => self.tcx.types.f64,
2913 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2914 Neither => return false,
2916 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2917 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2921 fn select_all_obligations_or_error(&self) {
2922 debug!("select_all_obligations_or_error");
2923 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2924 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2928 /// Select as many obligations as we can at present.
2929 fn select_obligations_where_possible(
2931 fallback_has_occurred: bool,
2932 mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
2934 if let Err(mut errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2935 mutate_fullfillment_errors(&mut errors);
2936 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2940 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2941 /// returns a type of `&T`, but the actual type we assign to the
2942 /// *expression* is `T`. So this function just peels off the return
2943 /// type by one layer to yield `T`.
2944 fn make_overloaded_place_return_type(&self,
2945 method: MethodCallee<'tcx>)
2946 -> ty::TypeAndMut<'tcx>
2948 // extract method return type, which will be &T;
2949 let ret_ty = method.sig.output();
2951 // method returns &T, but the type as visible to user is T, so deref
2952 ret_ty.builtin_deref(true).unwrap()
2958 base_expr: &'tcx hir::Expr,
2962 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2963 // FIXME(#18741) -- this is almost but not quite the same as the
2964 // autoderef that normal method probing does. They could likely be
2967 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2968 let mut result = None;
2969 while result.is_none() && autoderef.next().is_some() {
2970 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2972 autoderef.finalize(self);
2976 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2977 /// (and otherwise adjust) `base_expr`, looking for a type which either
2978 /// supports builtin indexing or overloaded indexing.
2979 /// This loop implements one step in that search; the autoderef loop
2980 /// is implemented by `lookup_indexing`.
2984 base_expr: &hir::Expr,
2985 autoderef: &Autoderef<'a, 'tcx>,
2988 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2989 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2990 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2997 for &unsize in &[false, true] {
2998 let mut self_ty = adjusted_ty;
3000 // We only unsize arrays here.
3001 if let ty::Array(element_ty, _) = adjusted_ty.kind {
3002 self_ty = self.tcx.mk_slice(element_ty);
3008 // If some lookup succeeds, write callee into table and extract index/element
3009 // type from the method signature.
3010 // If some lookup succeeded, install method in table
3011 let input_ty = self.next_ty_var(TypeVariableOrigin {
3012 kind: TypeVariableOriginKind::AutoDeref,
3013 span: base_expr.span,
3015 let method = self.try_overloaded_place_op(
3016 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
3018 let result = method.map(|ok| {
3019 debug!("try_index_step: success, using overloaded indexing");
3020 let method = self.register_infer_ok_obligations(ok);
3022 let mut adjustments = autoderef.adjust_steps(self, needs);
3023 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].kind {
3024 let mutbl = match r_mutbl {
3025 hir::MutImmutable => AutoBorrowMutability::Immutable,
3026 hir::MutMutable => AutoBorrowMutability::Mutable {
3027 // Indexing can be desugared to a method call,
3028 // so maybe we could use two-phase here.
3029 // See the documentation of AllowTwoPhase for why that's
3030 // not the case today.
3031 allow_two_phase_borrow: AllowTwoPhase::No,
3034 adjustments.push(Adjustment {
3035 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
3036 target: self.tcx.mk_ref(region, ty::TypeAndMut {
3043 adjustments.push(Adjustment {
3044 kind: Adjust::Pointer(PointerCast::Unsize),
3045 target: method.sig.inputs()[0]
3048 self.apply_adjustments(base_expr, adjustments);
3050 self.write_method_call(expr.hir_id, method);
3051 (input_ty, self.make_overloaded_place_return_type(method).ty)
3053 if result.is_some() {
3061 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3062 let (tr, name) = match (op, is_mut) {
3063 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3064 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3065 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3066 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3068 (tr, ast::Ident::with_dummy_span(name))
3071 fn try_overloaded_place_op(&self,
3074 arg_tys: &[Ty<'tcx>],
3077 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3079 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3085 // Try Mut first, if needed.
3086 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3087 let method = match (needs, mut_tr) {
3088 (Needs::MutPlace, Some(trait_did)) => {
3089 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3094 // Otherwise, fall back to the immutable version.
3095 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3096 let method = match (method, imm_tr) {
3097 (None, Some(trait_did)) => {
3098 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3100 (method, _) => method,
3106 fn check_method_argument_types(
3109 expr: &'tcx hir::Expr,
3110 method: Result<MethodCallee<'tcx>, ()>,
3111 args_no_rcvr: &'tcx [hir::Expr],
3112 tuple_arguments: TupleArgumentsFlag,
3113 expected: Expectation<'tcx>,
3116 let has_error = match method {
3118 method.substs.references_error() || method.sig.references_error()
3123 let err_inputs = self.err_args(args_no_rcvr.len());
3125 let err_inputs = match tuple_arguments {
3126 DontTupleArguments => err_inputs,
3127 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3130 self.check_argument_types(
3140 return self.tcx.types.err;
3143 let method = method.unwrap();
3144 // HACK(eddyb) ignore self in the definition (see above).
3145 let expected_arg_tys = self.expected_inputs_for_expected_output(
3148 method.sig.output(),
3149 &method.sig.inputs()[1..]
3151 self.check_argument_types(
3154 &method.sig.inputs()[1..],
3155 &expected_arg_tys[..],
3157 method.sig.c_variadic,
3159 self.tcx.hir().span_if_local(method.def_id),
3164 fn self_type_matches_expected_vid(
3166 trait_ref: ty::PolyTraitRef<'tcx>,
3167 expected_vid: ty::TyVid,
3169 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3171 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3172 trait_ref, self_ty, expected_vid
3174 match self_ty.kind {
3175 ty::Infer(ty::TyVar(found_vid)) => {
3176 // FIXME: consider using `sub_root_var` here so we
3177 // can see through subtyping.
3178 let found_vid = self.root_var(found_vid);
3179 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3180 expected_vid == found_vid
3186 fn obligations_for_self_ty<'b>(
3189 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3192 // FIXME: consider using `sub_root_var` here so we
3193 // can see through subtyping.
3194 let ty_var_root = self.root_var(self_ty);
3195 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3196 self_ty, ty_var_root,
3197 self.fulfillment_cx.borrow().pending_obligations());
3201 .pending_obligations()
3203 .filter_map(move |obligation| match obligation.predicate {
3204 ty::Predicate::Projection(ref data) =>
3205 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3206 ty::Predicate::Trait(ref data) =>
3207 Some((data.to_poly_trait_ref(), obligation)),
3208 ty::Predicate::Subtype(..) => None,
3209 ty::Predicate::RegionOutlives(..) => None,
3210 ty::Predicate::TypeOutlives(..) => None,
3211 ty::Predicate::WellFormed(..) => None,
3212 ty::Predicate::ObjectSafe(..) => None,
3213 ty::Predicate::ConstEvaluatable(..) => None,
3214 // N.B., this predicate is created by breaking down a
3215 // `ClosureType: FnFoo()` predicate, where
3216 // `ClosureType` represents some `Closure`. It can't
3217 // possibly be referring to the current closure,
3218 // because we haven't produced the `Closure` for
3219 // this closure yet; this is exactly why the other
3220 // code is looking for a self type of a unresolved
3221 // inference variable.
3222 ty::Predicate::ClosureKind(..) => None,
3223 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3226 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3227 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3228 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3232 /// Generic function that factors out common logic from function calls,
3233 /// method calls and overloaded operators.
3234 fn check_argument_types(
3237 expr: &'tcx hir::Expr,
3238 fn_inputs: &[Ty<'tcx>],
3239 expected_arg_tys: &[Ty<'tcx>],
3240 args: &'tcx [hir::Expr],
3242 tuple_arguments: TupleArgumentsFlag,
3243 def_span: Option<Span>,
3246 // Grab the argument types, supplying fresh type variables
3247 // if the wrong number of arguments were supplied
3248 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3254 // All the input types from the fn signature must outlive the call
3255 // so as to validate implied bounds.
3256 for (fn_input_ty, arg_expr) in fn_inputs.iter().zip(args.iter()) {
3257 self.register_wf_obligation(fn_input_ty, arg_expr.span, traits::MiscObligation);
3260 let expected_arg_count = fn_inputs.len();
3262 let param_count_error = |expected_count: usize,
3267 let mut err = tcx.sess.struct_span_err_with_code(sp,
3268 &format!("this function takes {}{} but {} {} supplied",
3269 if c_variadic { "at least " } else { "" },
3270 potentially_plural_count(expected_count, "parameter"),
3271 potentially_plural_count(arg_count, "parameter"),
3272 if arg_count == 1 {"was"} else {"were"}),
3273 DiagnosticId::Error(error_code.to_owned()));
3275 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3276 err.span_label(def_s, "defined here");
3279 let sugg_span = tcx.sess.source_map().end_point(expr.span);
3280 // remove closing `)` from the span
3281 let sugg_span = sugg_span.shrink_to_lo();
3282 err.span_suggestion(
3284 "expected the unit value `()`; create it with empty parentheses",
3286 Applicability::MachineApplicable);
3288 err.span_label(sp, format!("expected {}{}",
3289 if c_variadic { "at least " } else { "" },
3290 potentially_plural_count(expected_count, "parameter")));
3295 let mut expected_arg_tys = expected_arg_tys.to_vec();
3297 let formal_tys = if tuple_arguments == TupleArguments {
3298 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3299 match tuple_type.kind {
3300 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3301 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3302 expected_arg_tys = vec![];
3303 self.err_args(args.len())
3305 ty::Tuple(arg_types) => {
3306 expected_arg_tys = match expected_arg_tys.get(0) {
3307 Some(&ty) => match ty.kind {
3308 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3313 arg_types.iter().map(|k| k.expect_ty()).collect()
3316 span_err!(tcx.sess, sp, E0059,
3317 "cannot use call notation; the first type parameter \
3318 for the function trait is neither a tuple nor unit");
3319 expected_arg_tys = vec![];
3320 self.err_args(args.len())
3323 } else if expected_arg_count == supplied_arg_count {
3325 } else if c_variadic {
3326 if supplied_arg_count >= expected_arg_count {
3329 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3330 expected_arg_tys = vec![];
3331 self.err_args(supplied_arg_count)
3334 // is the missing argument of type `()`?
3335 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3336 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3337 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3338 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3342 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3344 expected_arg_tys = vec![];
3345 self.err_args(supplied_arg_count)
3348 debug!("check_argument_types: formal_tys={:?}",
3349 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3351 // If there is no expectation, expect formal_tys.
3352 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3358 let mut final_arg_types: Vec<(usize, Ty<'_>)> = vec![];
3360 // Check the arguments.
3361 // We do this in a pretty awful way: first we type-check any arguments
3362 // that are not closures, then we type-check the closures. This is so
3363 // that we have more information about the types of arguments when we
3364 // type-check the functions. This isn't really the right way to do this.
3365 for &check_closures in &[false, true] {
3366 debug!("check_closures={}", check_closures);
3368 // More awful hacks: before we check argument types, try to do
3369 // an "opportunistic" vtable resolution of any trait bounds on
3370 // the call. This helps coercions.
3372 self.select_obligations_where_possible(false, |errors| {
3373 self.point_at_type_arg_instead_of_call_if_possible(errors, expr);
3374 self.point_at_arg_instead_of_call_if_possible(
3376 &final_arg_types[..],
3383 // For C-variadic functions, we don't have a declared type for all of
3384 // the arguments hence we only do our usual type checking with
3385 // the arguments who's types we do know.
3386 let t = if c_variadic {
3388 } else if tuple_arguments == TupleArguments {
3393 for (i, arg) in args.iter().take(t).enumerate() {
3394 // Warn only for the first loop (the "no closures" one).
3395 // Closure arguments themselves can't be diverging, but
3396 // a previous argument can, e.g., `foo(panic!(), || {})`.
3397 if !check_closures {
3398 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3401 let is_closure = match arg.kind {
3402 ExprKind::Closure(..) => true,
3406 if is_closure != check_closures {
3410 debug!("checking the argument");
3411 let formal_ty = formal_tys[i];
3413 // The special-cased logic below has three functions:
3414 // 1. Provide as good of an expected type as possible.
3415 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3417 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3419 // 2. Coerce to the most detailed type that could be coerced
3420 // to, which is `expected_ty` if `rvalue_hint` returns an
3421 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3422 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3423 // We're processing function arguments so we definitely want to use
3424 // two-phase borrows.
3425 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3426 final_arg_types.push((i, coerce_ty));
3428 // 3. Relate the expected type and the formal one,
3429 // if the expected type was used for the coercion.
3430 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3434 // We also need to make sure we at least write the ty of the other
3435 // arguments which we skipped above.
3437 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3438 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3439 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3442 for arg in args.iter().skip(expected_arg_count) {
3443 let arg_ty = self.check_expr(&arg);
3445 // There are a few types which get autopromoted when passed via varargs
3446 // in C but we just error out instead and require explicit casts.
3447 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3449 ty::Float(ast::FloatTy::F32) => {
3450 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3452 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3453 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3455 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3456 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3459 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3460 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3461 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3469 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3470 vec![self.tcx.types.err; len]
3473 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call argument expressions, we
3474 /// walk the resolved types for each argument to see if any of the `FullfillmentError`s
3475 /// reference a type argument. If they do, and there's only *one* argument that does, we point
3476 /// at the corresponding argument's expression span instead of the `fn` call path span.
3477 fn point_at_arg_instead_of_call_if_possible(
3479 errors: &mut Vec<traits::FulfillmentError<'_>>,
3480 final_arg_types: &[(usize, Ty<'tcx>)],
3482 args: &'tcx [hir::Expr],
3484 if !call_sp.desugaring_kind().is_some() {
3485 // We *do not* do this for desugared call spans to keep good diagnostics when involving
3486 // the `?` operator.
3487 for error in errors {
3488 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3489 // Collect the argument position for all arguments that could have caused this
3490 // `FullfillmentError`.
3491 let mut referenced_in = final_arg_types.iter()
3492 .flat_map(|(i, ty)| {
3493 let ty = self.resolve_vars_if_possible(ty);
3494 // We walk the argument type because the argument's type could have
3495 // been `Option<T>`, but the `FullfillmentError` references `T`.
3497 .filter(|&ty| ty == predicate.skip_binder().self_ty())
3500 if let (Some(ref_in), None) = (referenced_in.next(), referenced_in.next()) {
3501 // We make sure that only *one* argument matches the obligation failure
3502 // and thet the obligation's span to its expression's.
3503 error.obligation.cause.span = args[ref_in].span;
3504 error.points_at_arg_span = true;
3511 /// Given a vec of evaluated `FullfillmentError`s and an `fn` call expression, we walk the
3512 /// `PathSegment`s and resolve their type parameters to see if any of the `FullfillmentError`s
3513 /// were caused by them. If they were, we point at the corresponding type argument's span
3514 /// instead of the `fn` call path span.
3515 fn point_at_type_arg_instead_of_call_if_possible(
3517 errors: &mut Vec<traits::FulfillmentError<'_>>,
3518 call_expr: &'tcx hir::Expr,
3520 if let hir::ExprKind::Call(path, _) = &call_expr.kind {
3521 if let hir::ExprKind::Path(qpath) = &path.kind {
3522 if let hir::QPath::Resolved(_, path) = &qpath {
3523 for error in errors {
3524 if let ty::Predicate::Trait(predicate) = error.obligation.predicate {
3525 // If any of the type arguments in this path segment caused the
3526 // `FullfillmentError`, point at its span (#61860).
3527 for arg in path.segments.iter()
3528 .filter_map(|seg| seg.args.as_ref())
3529 .flat_map(|a| a.args.iter())
3531 if let hir::GenericArg::Type(hir_ty) = &arg {
3532 if let hir::TyKind::Path(
3533 hir::QPath::TypeRelative(..),
3535 // Avoid ICE with associated types. As this is best
3536 // effort only, it's ok to ignore the case. It
3537 // would trigger in `is_send::<T::AssocType>();`
3538 // from `typeck-default-trait-impl-assoc-type.rs`.
3540 let ty = AstConv::ast_ty_to_ty(self, hir_ty);
3541 let ty = self.resolve_vars_if_possible(&ty);
3542 if ty == predicate.skip_binder().self_ty() {
3543 error.obligation.cause.span = hir_ty.span;
3555 // AST fragment checking
3558 expected: Expectation<'tcx>)
3564 ast::LitKind::Str(..) => tcx.mk_static_str(),
3565 ast::LitKind::ByteStr(ref v) => {
3566 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3567 tcx.mk_array(tcx.types.u8, v.len() as u64))
3569 ast::LitKind::Byte(_) => tcx.types.u8,
3570 ast::LitKind::Char(_) => tcx.types.char,
3571 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3572 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3573 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3574 let opt_ty = expected.to_option(self).and_then(|ty| {
3576 ty::Int(_) | ty::Uint(_) => Some(ty),
3577 ty::Char => Some(tcx.types.u8),
3578 ty::RawPtr(..) => Some(tcx.types.usize),
3579 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3583 opt_ty.unwrap_or_else(|| self.next_int_var())
3585 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3586 ast::LitKind::FloatUnsuffixed(_) => {
3587 let opt_ty = expected.to_option(self).and_then(|ty| {
3589 ty::Float(_) => Some(ty),
3593 opt_ty.unwrap_or_else(|| self.next_float_var())
3595 ast::LitKind::Bool(_) => tcx.types.bool,
3596 ast::LitKind::Err(_) => tcx.types.err,
3600 // Determine the `Self` type, using fresh variables for all variables
3601 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3602 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3604 pub fn impl_self_ty(&self,
3605 span: Span, // (potential) receiver for this impl
3607 -> TypeAndSubsts<'tcx> {
3608 let ity = self.tcx.type_of(did);
3609 debug!("impl_self_ty: ity={:?}", ity);
3611 let substs = self.fresh_substs_for_item(span, did);
3612 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3614 TypeAndSubsts { substs: substs, ty: substd_ty }
3617 /// Unifies the output type with the expected type early, for more coercions
3618 /// and forward type information on the input expressions.
3619 fn expected_inputs_for_expected_output(&self,
3621 expected_ret: Expectation<'tcx>,
3622 formal_ret: Ty<'tcx>,
3623 formal_args: &[Ty<'tcx>])
3625 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3626 let ret_ty = match expected_ret.only_has_type(self) {
3628 None => return Vec::new()
3630 let expect_args = self.fudge_inference_if_ok(|| {
3631 // Attempt to apply a subtyping relationship between the formal
3632 // return type (likely containing type variables if the function
3633 // is polymorphic) and the expected return type.
3634 // No argument expectations are produced if unification fails.
3635 let origin = self.misc(call_span);
3636 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3638 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3639 // to identity so the resulting type is not constrained.
3642 // Process any obligations locally as much as
3643 // we can. We don't care if some things turn
3644 // out unconstrained or ambiguous, as we're
3645 // just trying to get hints here.
3646 self.save_and_restore_in_snapshot_flag(|_| {
3647 let mut fulfill = TraitEngine::new(self.tcx);
3648 for obligation in ok.obligations {
3649 fulfill.register_predicate_obligation(self, obligation);
3651 fulfill.select_where_possible(self)
3652 }).map_err(|_| ())?;
3654 Err(_) => return Err(()),
3657 // Record all the argument types, with the substitutions
3658 // produced from the above subtyping unification.
3659 Ok(formal_args.iter().map(|ty| {
3660 self.resolve_vars_if_possible(ty)
3662 }).unwrap_or_default();
3663 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3664 formal_args, formal_ret,
3665 expect_args, expected_ret);
3669 pub fn check_struct_path(&self,
3672 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3673 let path_span = match *qpath {
3674 QPath::Resolved(_, ref path) => path.span,
3675 QPath::TypeRelative(ref qself, _) => qself.span
3677 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3678 let variant = match def {
3680 self.set_tainted_by_errors();
3683 Res::Def(DefKind::Variant, _) => {
3685 ty::Adt(adt, substs) => {
3686 Some((adt.variant_of_res(def), adt.did, substs))
3688 _ => bug!("unexpected type: {:?}", ty)
3691 Res::Def(DefKind::Struct, _)
3692 | Res::Def(DefKind::Union, _)
3693 | Res::Def(DefKind::TyAlias, _)
3694 | Res::Def(DefKind::AssocTy, _)
3695 | Res::SelfTy(..) => {
3697 ty::Adt(adt, substs) if !adt.is_enum() => {
3698 Some((adt.non_enum_variant(), adt.did, substs))
3703 _ => bug!("unexpected definition: {:?}", def)
3706 if let Some((variant, did, substs)) = variant {
3707 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3708 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3710 // Check bounds on type arguments used in the path.
3711 let (bounds, _) = self.instantiate_bounds(path_span, did, substs);
3712 let cause = traits::ObligationCause::new(
3715 traits::ItemObligation(did),
3717 self.add_obligations_for_parameters(cause, &bounds);
3721 struct_span_err!(self.tcx.sess, path_span, E0071,
3722 "expected struct, variant or union type, found {}",
3723 ty.sort_string(self.tcx))
3724 .span_label(path_span, "not a struct")
3730 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3731 // The newly resolved definition is written into `type_dependent_defs`.
3732 fn finish_resolving_struct_path(&self,
3739 QPath::Resolved(ref maybe_qself, ref path) => {
3740 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3741 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3744 QPath::TypeRelative(ref qself, ref segment) => {
3745 let ty = self.to_ty(qself);
3747 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.kind {
3752 let result = AstConv::associated_path_to_ty(
3761 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3762 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3764 // Write back the new resolution.
3765 self.write_resolution(hir_id, result);
3767 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3772 /// Resolves an associated value path into a base type and associated constant, or method
3773 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3774 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3778 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3780 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3781 let (ty, qself, item_segment) = match *qpath {
3782 QPath::Resolved(ref opt_qself, ref path) => {
3784 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3785 &path.segments[..]);
3787 QPath::TypeRelative(ref qself, ref segment) => {
3788 (self.to_ty(qself), qself, segment)
3791 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3792 // Return directly on cache hit. This is useful to avoid doubly reporting
3793 // errors with default match binding modes. See #44614.
3794 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3795 .unwrap_or(Res::Err);
3796 return (def, Some(ty), slice::from_ref(&**item_segment));
3798 let item_name = item_segment.ident;
3799 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3800 let result = match error {
3801 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3802 _ => Err(ErrorReported),
3804 if item_name.name != kw::Invalid {
3805 self.report_method_error(
3809 SelfSource::QPath(qself),
3812 ).map(|mut e| e.emit());
3817 // Write back the new resolution.
3818 self.write_resolution(hir_id, result);
3820 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3822 slice::from_ref(&**item_segment),
3826 pub fn check_decl_initializer(
3828 local: &'tcx hir::Local,
3829 init: &'tcx hir::Expr,
3831 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3832 // for #42640 (default match binding modes).
3835 let ref_bindings = local.pat.contains_explicit_ref_binding();
3837 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3838 if let Some(m) = ref_bindings {
3839 // Somewhat subtle: if we have a `ref` binding in the pattern,
3840 // we want to avoid introducing coercions for the RHS. This is
3841 // both because it helps preserve sanity and, in the case of
3842 // ref mut, for soundness (issue #23116). In particular, in
3843 // the latter case, we need to be clear that the type of the
3844 // referent for the reference that results is *equal to* the
3845 // type of the place it is referencing, and not some
3846 // supertype thereof.
3847 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3848 self.demand_eqtype(init.span, local_ty, init_ty);
3851 self.check_expr_coercable_to_type(init, local_ty)
3855 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3856 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3857 self.write_ty(local.hir_id, t);
3859 if let Some(ref init) = local.init {
3860 let init_ty = self.check_decl_initializer(local, &init);
3861 self.overwrite_local_ty_if_err(local, t, init_ty);
3864 self.check_pat_top(&local.pat, t, None);
3865 let pat_ty = self.node_ty(local.pat.hir_id);
3866 self.overwrite_local_ty_if_err(local, t, pat_ty);
3869 fn overwrite_local_ty_if_err(&self, local: &'tcx hir::Local, decl_ty: Ty<'tcx>, ty: Ty<'tcx>) {
3870 if ty.references_error() {
3871 // Override the types everywhere with `types.err` to avoid knock down errors.
3872 self.write_ty(local.hir_id, ty);
3873 self.write_ty(local.pat.hir_id, ty);
3874 let local_ty = LocalTy {
3878 self.locals.borrow_mut().insert(local.hir_id, local_ty);
3879 self.locals.borrow_mut().insert(local.pat.hir_id, local_ty);
3883 fn suggest_semicolon_at_end(&self, span: Span, err: &mut DiagnosticBuilder<'_>) {
3884 err.span_suggestion_short(
3885 span.shrink_to_hi(),
3886 "consider using a semicolon here",
3888 Applicability::MachineApplicable,
3892 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3893 // Don't do all the complex logic below for `DeclItem`.
3895 hir::StmtKind::Item(..) => return,
3896 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3899 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3901 // Hide the outer diverging and `has_errors` flags.
3902 let old_diverges = self.diverges.get();
3903 let old_has_errors = self.has_errors.get();
3904 self.diverges.set(Diverges::Maybe);
3905 self.has_errors.set(false);
3908 hir::StmtKind::Local(ref l) => {
3909 self.check_decl_local(&l);
3912 hir::StmtKind::Item(_) => {}
3913 hir::StmtKind::Expr(ref expr) => {
3914 // Check with expected type of `()`.
3916 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit(), |err| {
3917 self.suggest_semicolon_at_end(expr.span, err);
3920 hir::StmtKind::Semi(ref expr) => {
3921 self.check_expr(&expr);
3925 // Combine the diverging and `has_error` flags.
3926 self.diverges.set(self.diverges.get() | old_diverges);
3927 self.has_errors.set(self.has_errors.get() | old_has_errors);
3930 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3931 let unit = self.tcx.mk_unit();
3932 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3934 // if the block produces a `!` value, that can always be
3935 // (effectively) coerced to unit.
3937 self.demand_suptype(blk.span, unit, ty);
3941 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
3942 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
3943 /// when given code like the following:
3945 /// if false { return 0i32; } else { 1u32 }
3946 /// // ^^^^ point at this instead of the whole `if` expression
3948 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
3949 if let hir::ExprKind::Match(_, arms, _) = &expr.kind {
3950 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
3951 self.in_progress_tables
3952 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
3953 .and_then(|arm_ty| {
3954 if arm_ty.is_never() {
3957 Some(match &arm.body.kind {
3958 // Point at the tail expression when possible.
3959 hir::ExprKind::Block(block, _) => block.expr
3962 .unwrap_or(block.span),
3968 if arm_spans.len() == 1 {
3969 return arm_spans[0];
3975 fn check_block_with_expected(
3977 blk: &'tcx hir::Block,
3978 expected: Expectation<'tcx>,
3981 let mut fcx_ps = self.ps.borrow_mut();
3982 let unsafety_state = fcx_ps.recurse(blk);
3983 replace(&mut *fcx_ps, unsafety_state)
3986 // In some cases, blocks have just one exit, but other blocks
3987 // can be targeted by multiple breaks. This can happen both
3988 // with labeled blocks as well as when we desugar
3989 // a `try { ... }` expression.
3993 // 'a: { if true { break 'a Err(()); } Ok(()) }
3995 // Here we would wind up with two coercions, one from
3996 // `Err(())` and the other from the tail expression
3997 // `Ok(())`. If the tail expression is omitted, that's a
3998 // "forced unit" -- unless the block diverges, in which
3999 // case we can ignore the tail expression (e.g., `'a: {
4000 // break 'a 22; }` would not force the type of the block
4002 let tail_expr = blk.expr.as_ref();
4003 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
4004 let coerce = if blk.targeted_by_break {
4005 CoerceMany::new(coerce_to_ty)
4007 let tail_expr: &[P<hir::Expr>] = match tail_expr {
4008 Some(e) => slice::from_ref(e),
4011 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
4014 let prev_diverges = self.diverges.get();
4015 let ctxt = BreakableCtxt {
4016 coerce: Some(coerce),
4020 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
4021 for s in &blk.stmts {
4025 // check the tail expression **without** holding the
4026 // `enclosing_breakables` lock below.
4027 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
4029 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4030 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
4031 let coerce = ctxt.coerce.as_mut().unwrap();
4032 if let Some(tail_expr_ty) = tail_expr_ty {
4033 let tail_expr = tail_expr.unwrap();
4034 let span = self.get_expr_coercion_span(tail_expr);
4035 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
4036 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
4038 // Subtle: if there is no explicit tail expression,
4039 // that is typically equivalent to a tail expression
4040 // of `()` -- except if the block diverges. In that
4041 // case, there is no value supplied from the tail
4042 // expression (assuming there are no other breaks,
4043 // this implies that the type of the block will be
4046 // #41425 -- label the implicit `()` as being the
4047 // "found type" here, rather than the "expected type".
4048 if !self.diverges.get().is_always() {
4049 // #50009 -- Do not point at the entire fn block span, point at the return type
4050 // span, as it is the cause of the requirement, and
4051 // `consider_hint_about_removing_semicolon` will point at the last expression
4052 // if it were a relevant part of the error. This improves usability in editors
4053 // that highlight errors inline.
4054 let mut sp = blk.span;
4055 let mut fn_span = None;
4056 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
4057 let ret_sp = decl.output.span();
4058 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
4059 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
4060 // output would otherwise be incorrect and even misleading. Make sure
4061 // the span we're aiming at correspond to a `fn` body.
4062 if block_sp == blk.span {
4064 fn_span = Some(ident.span);
4068 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
4069 if let Some(expected_ty) = expected.only_has_type(self) {
4070 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
4072 if let Some(fn_span) = fn_span {
4075 "implicitly returns `()` as its body has no tail or `return` \
4085 // If we can break from the block, then the block's exit is always reachable
4086 // (... as long as the entry is reachable) - regardless of the tail of the block.
4087 self.diverges.set(prev_diverges);
4090 let mut ty = ctxt.coerce.unwrap().complete(self);
4092 if self.has_errors.get() || ty.references_error() {
4093 ty = self.tcx.types.err
4096 self.write_ty(blk.hir_id, ty);
4098 *self.ps.borrow_mut() = prev;
4102 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
4103 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
4105 Node::Item(&hir::Item {
4106 kind: hir::ItemKind::Fn(_, _, _, body_id), ..
4108 Node::ImplItem(&hir::ImplItem {
4109 kind: hir::ImplItemKind::Method(_, body_id), ..
4111 let body = self.tcx.hir().body(body_id);
4112 if let ExprKind::Block(block, _) = &body.value.kind {
4113 return Some(block.span);
4121 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
4122 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
4123 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
4124 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
4127 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
4128 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
4130 Node::Item(&hir::Item {
4131 ident, kind: hir::ItemKind::Fn(ref decl, ..), ..
4133 // This is less than ideal, it will not suggest a return type span on any
4134 // method called `main`, regardless of whether it is actually the entry point,
4135 // but it will still present it as the reason for the expected type.
4136 Some((decl, ident, ident.name != sym::main))
4138 Node::TraitItem(&hir::TraitItem {
4139 ident, kind: hir::TraitItemKind::Method(hir::MethodSig {
4142 }) => Some((decl, ident, true)),
4143 Node::ImplItem(&hir::ImplItem {
4144 ident, kind: hir::ImplItemKind::Method(hir::MethodSig {
4147 }) => Some((decl, ident, false)),
4152 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
4153 /// suggestion can be made, `None` otherwise.
4154 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
4155 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
4156 // `while` before reaching it, as block tail returns are not available in them.
4157 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
4158 let parent = self.tcx.hir().get(blk_id);
4159 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
4163 /// On implicit return expressions with mismatched types, provides the following suggestions:
4165 /// - Points out the method's return type as the reason for the expected type.
4166 /// - Possible missing semicolon.
4167 /// - Possible missing return type if the return type is the default, and not `fn main()`.
4168 pub fn suggest_mismatched_types_on_tail(
4170 err: &mut DiagnosticBuilder<'tcx>,
4171 expression: &'tcx hir::Expr,
4177 self.suggest_missing_semicolon(err, expression, expected, cause_span);
4178 let mut pointing_at_return_type = false;
4179 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4180 pointing_at_return_type = self.suggest_missing_return_type(
4181 err, &fn_decl, expected, found, can_suggest);
4183 self.suggest_ref_or_into(err, expression, expected, found);
4184 self.suggest_boxing_when_appropriate(err, expression, expected, found);
4185 pointing_at_return_type
4188 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
4189 /// the ctor would successfully solve the type mismatch and if so, suggest it:
4191 /// fn foo(x: usize) -> usize { x }
4192 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4196 err: &mut DiagnosticBuilder<'tcx>,
4201 let hir = self.tcx.hir();
4202 let (def_id, sig) = match found.kind {
4203 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4204 ty::Closure(def_id, substs) => {
4205 // We don't use `closure_sig` to account for malformed closures like
4206 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4207 let closure_sig_ty = substs.closure_sig_ty(def_id, self.tcx);
4208 (def_id, match closure_sig_ty.kind {
4209 ty::FnPtr(sig) => sig,
4217 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4219 let sig = self.normalize_associated_types_in(expr.span, &sig);
4220 if self.can_coerce(sig.output(), expected) {
4221 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4222 (String::new(), Applicability::MachineApplicable)
4224 ("...".to_string(), Applicability::HasPlaceholders)
4226 let mut msg = "call this function";
4227 match hir.get_if_local(def_id) {
4228 Some(Node::Item(hir::Item {
4229 kind: ItemKind::Fn(.., body_id),
4232 Some(Node::ImplItem(hir::ImplItem {
4233 kind: hir::ImplItemKind::Method(_, body_id),
4236 Some(Node::TraitItem(hir::TraitItem {
4237 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4240 let body = hir.body(*body_id);
4241 sugg_call = body.params.iter()
4242 .map(|param| match ¶m.pat.kind {
4243 hir::PatKind::Binding(_, _, ident, None)
4244 if ident.name != kw::SelfLower => ident.to_string(),
4245 _ => "_".to_string(),
4246 }).collect::<Vec<_>>().join(", ");
4248 Some(Node::Expr(hir::Expr {
4249 kind: ExprKind::Closure(_, _, body_id, closure_span, _),
4250 span: full_closure_span,
4253 if *full_closure_span == expr.span {
4256 err.span_label(*closure_span, "closure defined here");
4257 msg = "call this closure";
4258 let body = hir.body(*body_id);
4259 sugg_call = body.params.iter()
4260 .map(|param| match ¶m.pat.kind {
4261 hir::PatKind::Binding(_, _, ident, None)
4262 if ident.name != kw::SelfLower => ident.to_string(),
4263 _ => "_".to_string(),
4264 }).collect::<Vec<_>>().join(", ");
4266 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4267 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4268 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4269 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4270 msg = "instantiate this tuple variant";
4272 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4273 msg = "instantiate this tuple struct";
4278 Some(Node::ForeignItem(hir::ForeignItem {
4279 kind: hir::ForeignItemKind::Fn(_, idents, _),
4282 Some(Node::TraitItem(hir::TraitItem {
4283 kind: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4285 })) => sugg_call = idents.iter()
4286 .map(|ident| if ident.name != kw::SelfLower {
4290 }).collect::<Vec<_>>()
4294 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4295 err.span_suggestion(
4297 &format!("use parentheses to {}", msg),
4298 format!("{}({})", code, sugg_call),
4307 pub fn suggest_ref_or_into(
4309 err: &mut DiagnosticBuilder<'tcx>,
4314 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4315 err.span_suggestion(
4319 Applicability::MachineApplicable,
4321 } else if let (ty::FnDef(def_id, ..), true) = (
4323 self.suggest_fn_call(err, expr, expected, found),
4325 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4326 let sp = self.sess().source_map().def_span(sp);
4327 err.span_label(sp, &format!("{} defined here", found));
4329 } else if !self.check_for_cast(err, expr, found, expected) {
4330 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4334 let methods = self.get_conversion_methods(expr.span, expected, found);
4335 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4336 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4337 .filter_map(|(receiver, method)| {
4338 let method_call = format!(".{}()", method.ident);
4339 if receiver.ends_with(&method_call) {
4340 None // do not suggest code that is already there (#53348)
4342 let method_call_list = [".to_vec()", ".to_string()"];
4343 let sugg = if receiver.ends_with(".clone()")
4344 && method_call_list.contains(&method_call.as_str()) {
4345 let max_len = receiver.rfind(".").unwrap();
4346 format!("{}{}", &receiver[..max_len], method_call)
4348 format!("{}{}", receiver, method_call)
4350 Some(if is_struct_pat_shorthand_field {
4351 format!("{}: {}", receiver, sugg)
4357 if suggestions.peek().is_some() {
4358 err.span_suggestions(
4360 "try using a conversion method",
4362 Applicability::MaybeIncorrect,
4369 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4370 /// in the heap by calling `Box::new()`.
4371 fn suggest_boxing_when_appropriate(
4373 err: &mut DiagnosticBuilder<'tcx>,
4378 if self.tcx.hir().is_const_context(expr.hir_id) {
4379 // Do not suggest `Box::new` in const context.
4382 if !expected.is_box() || found.is_box() {
4385 let boxed_found = self.tcx.mk_box(found);
4386 if let (true, Ok(snippet)) = (
4387 self.can_coerce(boxed_found, expected),
4388 self.sess().source_map().span_to_snippet(expr.span),
4390 err.span_suggestion(
4392 "store this in the heap by calling `Box::new`",
4393 format!("Box::new({})", snippet),
4394 Applicability::MachineApplicable,
4396 err.note("for more on the distinction between the stack and the \
4397 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4398 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4399 https://doc.rust-lang.org/std/boxed/index.html");
4404 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4408 /// bar_that_returns_u32()
4412 /// This routine checks if the return expression in a block would make sense on its own as a
4413 /// statement and the return type has been left as default or has been specified as `()`. If so,
4414 /// it suggests adding a semicolon.
4415 fn suggest_missing_semicolon(
4417 err: &mut DiagnosticBuilder<'tcx>,
4418 expression: &'tcx hir::Expr,
4422 if expected.is_unit() {
4423 // `BlockTailExpression` only relevant if the tail expr would be
4424 // useful on its own.
4425 match expression.kind {
4426 ExprKind::Call(..) |
4427 ExprKind::MethodCall(..) |
4428 ExprKind::Loop(..) |
4429 ExprKind::Match(..) |
4430 ExprKind::Block(..) => {
4431 let sp = self.tcx.sess.source_map().next_point(cause_span);
4432 err.span_suggestion(
4434 "try adding a semicolon",
4436 Applicability::MachineApplicable);
4443 /// A possible error is to forget to add a return type that is needed:
4447 /// bar_that_returns_u32()
4451 /// This routine checks if the return type is left as default, the method is not part of an
4452 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4454 fn suggest_missing_return_type(
4456 err: &mut DiagnosticBuilder<'tcx>,
4457 fn_decl: &hir::FnDecl,
4462 // Only suggest changing the return type for methods that
4463 // haven't set a return type at all (and aren't `fn main()` or an impl).
4464 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4465 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4466 err.span_suggestion(
4468 "try adding a return type",
4469 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4470 Applicability::MachineApplicable);
4473 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4474 err.span_label(span, "possibly return type missing here?");
4477 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4478 // `fn main()` must return `()`, do not suggest changing return type
4479 err.span_label(span, "expected `()` because of default return type");
4482 // expectation was caused by something else, not the default return
4483 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4484 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4485 // Only point to return type if the expected type is the return type, as if they
4486 // are not, the expectation must have been caused by something else.
4487 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
4489 let ty = AstConv::ast_ty_to_ty(self, ty);
4490 debug!("suggest_missing_return_type: return type {:?}", ty);
4491 debug!("suggest_missing_return_type: expected type {:?}", ty);
4492 if ty.kind == expected.kind {
4493 err.span_label(sp, format!("expected `{}` because of return type",
4502 /// A possible error is to forget to add `.await` when using futures:
4505 /// async fn make_u32() -> u32 {
4509 /// fn take_u32(x: u32) {}
4511 /// async fn foo() {
4512 /// let x = make_u32();
4517 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4518 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4519 /// `.await` to the tail of the expression.
4520 fn suggest_missing_await(
4522 err: &mut DiagnosticBuilder<'tcx>,
4527 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4528 // body isn't `async`.
4529 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4530 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4531 let body = self.tcx().hir().body(body_id);
4532 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
4534 // Check for `Future` implementations by constructing a predicate to
4535 // prove: `<T as Future>::Output == U`
4536 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4537 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4538 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4539 // `<T as Future>::Output`
4540 projection_ty: ty::ProjectionTy {
4542 substs: self.tcx.mk_substs_trait(
4544 self.fresh_substs_for_item(sp, item_def_id)
4551 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4552 if self.infcx.predicate_may_hold(&obligation) {
4553 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4554 err.span_suggestion(
4556 "consider using `.await` here",
4557 format!("{}.await", code),
4558 Applicability::MaybeIncorrect,
4566 /// A common error is to add an extra semicolon:
4569 /// fn foo() -> usize {
4574 /// This routine checks if the final statement in a block is an
4575 /// expression with an explicit semicolon whose type is compatible
4576 /// with `expected_ty`. If so, it suggests removing the semicolon.
4577 fn consider_hint_about_removing_semicolon(
4579 blk: &'tcx hir::Block,
4580 expected_ty: Ty<'tcx>,
4581 err: &mut DiagnosticBuilder<'_>,
4583 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4584 err.span_suggestion(
4586 "consider removing this semicolon",
4588 Applicability::MachineApplicable,
4593 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4594 // Be helpful when the user wrote `{... expr;}` and
4595 // taking the `;` off is enough to fix the error.
4596 let last_stmt = blk.stmts.last()?;
4597 let last_expr = match last_stmt.kind {
4598 hir::StmtKind::Semi(ref e) => e,
4601 let last_expr_ty = self.node_ty(last_expr.hir_id);
4602 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4605 let original_span = original_sp(last_stmt.span, blk.span);
4606 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4609 // Instantiates the given path, which must refer to an item with the given
4610 // number of type parameters and type.
4611 pub fn instantiate_value_path(&self,
4612 segments: &[hir::PathSegment],
4613 self_ty: Option<Ty<'tcx>>,
4617 -> (Ty<'tcx>, Res) {
4619 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4628 let path_segs = match res {
4629 Res::Local(_) | Res::SelfCtor(_) => vec![],
4630 Res::Def(kind, def_id) =>
4631 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4632 _ => bug!("instantiate_value_path on {:?}", res),
4635 let mut user_self_ty = None;
4636 let mut is_alias_variant_ctor = false;
4638 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4639 if let Some(self_ty) = self_ty {
4640 let adt_def = self_ty.ty_adt_def().unwrap();
4641 user_self_ty = Some(UserSelfTy {
4642 impl_def_id: adt_def.did,
4645 is_alias_variant_ctor = true;
4648 Res::Def(DefKind::Method, def_id)
4649 | Res::Def(DefKind::AssocConst, def_id) => {
4650 let container = tcx.associated_item(def_id).container;
4651 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4653 ty::TraitContainer(trait_did) => {
4654 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4656 ty::ImplContainer(impl_def_id) => {
4657 if segments.len() == 1 {
4658 // `<T>::assoc` will end up here, and so
4659 // can `T::assoc`. It this came from an
4660 // inherent impl, we need to record the
4661 // `T` for posterity (see `UserSelfTy` for
4663 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4664 user_self_ty = Some(UserSelfTy {
4675 // Now that we have categorized what space the parameters for each
4676 // segment belong to, let's sort out the parameters that the user
4677 // provided (if any) into their appropriate spaces. We'll also report
4678 // errors if type parameters are provided in an inappropriate place.
4680 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4681 let generics_has_err = AstConv::prohibit_generics(
4682 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4683 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4690 if let Res::Local(hid) = res {
4691 let ty = self.local_ty(span, hid).decl_ty;
4692 let ty = self.normalize_associated_types_in(span, &ty);
4693 self.write_ty(hir_id, ty);
4697 if generics_has_err {
4698 // Don't try to infer type parameters when prohibited generic arguments were given.
4699 user_self_ty = None;
4702 // Now we have to compare the types that the user *actually*
4703 // provided against the types that were *expected*. If the user
4704 // did not provide any types, then we want to substitute inference
4705 // variables. If the user provided some types, we may still need
4706 // to add defaults. If the user provided *too many* types, that's
4709 let mut infer_args_for_err = FxHashSet::default();
4710 for &PathSeg(def_id, index) in &path_segs {
4711 let seg = &segments[index];
4712 let generics = tcx.generics_of(def_id);
4713 // Argument-position `impl Trait` is treated as a normal generic
4714 // parameter internally, but we don't allow users to specify the
4715 // parameter's value explicitly, so we have to do some error-
4717 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4722 false, // `is_method_call`
4724 if suppress_errors {
4725 infer_args_for_err.insert(index);
4726 self.set_tainted_by_errors(); // See issue #53251.
4730 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4731 tcx.generics_of(*def_id).has_self
4732 }).unwrap_or(false);
4734 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4735 let ty = self.impl_self_ty(span, impl_def_id).ty;
4736 let adt_def = ty.ty_adt_def();
4739 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4740 let variant = adt_def.non_enum_variant();
4741 let ctor_def_id = variant.ctor_def_id.unwrap();
4743 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4748 let mut err = tcx.sess.struct_span_err(span,
4749 "the `Self` constructor can only be used with tuple or unit structs");
4750 if let Some(adt_def) = adt_def {
4751 match adt_def.adt_kind() {
4753 err.help("did you mean to use one of the enum's variants?");
4757 err.span_suggestion(
4759 "use curly brackets",
4760 String::from("Self { /* fields */ }"),
4761 Applicability::HasPlaceholders,
4768 return (tcx.types.err, res)
4774 let def_id = res.def_id();
4776 // The things we are substituting into the type should not contain
4777 // escaping late-bound regions, and nor should the base type scheme.
4778 let ty = tcx.type_of(def_id);
4780 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4786 // Provide the generic args, and whether types should be inferred.
4788 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4791 // If we've encountered an `impl Trait`-related error, we're just
4792 // going to infer the arguments for better error messages.
4793 if !infer_args_for_err.contains(&index) {
4794 // Check whether the user has provided generic arguments.
4795 if let Some(ref data) = segments[index].args {
4796 return (Some(data), segments[index].infer_args);
4799 return (None, segments[index].infer_args);
4804 // Provide substitutions for parameters for which (valid) arguments have been provided.
4806 match (¶m.kind, arg) {
4807 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4808 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4810 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4811 self.to_ty(ty).into()
4813 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4814 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4816 _ => unreachable!(),
4819 // Provide substitutions for parameters for which arguments are inferred.
4820 |substs, param, infer_args| {
4822 GenericParamDefKind::Lifetime => {
4823 self.re_infer(Some(param), span).unwrap().into()
4825 GenericParamDefKind::Type { has_default, .. } => {
4826 if !infer_args && has_default {
4827 // If we have a default, then we it doesn't matter that we're not
4828 // inferring the type arguments: we provide the default where any
4830 let default = tcx.type_of(param.def_id);
4833 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4836 // If no type arguments were provided, we have to infer them.
4837 // This case also occurs as a result of some malformed input, e.g.
4838 // a lifetime argument being given instead of a type parameter.
4839 // Using inference instead of `Error` gives better error messages.
4840 self.var_for_def(span, param)
4843 GenericParamDefKind::Const => {
4844 // FIXME(const_generics:defaults)
4845 // No const parameters were provided, we have to infer them.
4846 self.var_for_def(span, param)
4851 assert!(!substs.has_escaping_bound_vars());
4852 assert!(!ty.has_escaping_bound_vars());
4854 // First, store the "user substs" for later.
4855 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4857 self.add_required_obligations(span, def_id, &substs);
4859 // Substitute the values for the type parameters into the type of
4860 // the referenced item.
4861 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4863 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4864 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4865 // is inherent, there is no `Self` parameter; instead, the impl needs
4866 // type parameters, which we can infer by unifying the provided `Self`
4867 // with the substituted impl type.
4868 // This also occurs for an enum variant on a type alias.
4869 let ty = tcx.type_of(impl_def_id);
4871 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4872 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4873 Ok(ok) => self.register_infer_ok_obligations(ok),
4875 self.tcx.sess.delay_span_bug(span, &format!(
4876 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4884 self.check_rustc_args_require_const(def_id, hir_id, span);
4886 debug!("instantiate_value_path: type of {:?} is {:?}",
4889 self.write_substs(hir_id, substs);
4891 (ty_substituted, res)
4894 /// Add all the obligations that are required, substituting and normalized appropriately.
4895 fn add_required_obligations(&self, span: Span, def_id: DefId, substs: &SubstsRef<'tcx>) {
4896 let (bounds, spans) = self.instantiate_bounds(span, def_id, &substs);
4898 for (i, mut obligation) in traits::predicates_for_generics(
4899 traits::ObligationCause::new(
4902 traits::ItemObligation(def_id),
4906 ).into_iter().enumerate() {
4907 // This makes the error point at the bound, but we want to point at the argument
4908 if let Some(span) = spans.get(i) {
4909 obligation.cause.code = traits::BindingObligation(def_id, *span);
4911 self.register_predicate(obligation);
4915 fn check_rustc_args_require_const(&self,
4919 // We're only interested in functions tagged with
4920 // #[rustc_args_required_const], so ignore anything that's not.
4921 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4925 // If our calling expression is indeed the function itself, we're good!
4926 // If not, generate an error that this can only be called directly.
4927 if let Node::Expr(expr) = self.tcx.hir().get(
4928 self.tcx.hir().get_parent_node(hir_id))
4930 if let ExprKind::Call(ref callee, ..) = expr.kind {
4931 if callee.hir_id == hir_id {
4937 self.tcx.sess.span_err(span, "this function can only be invoked \
4938 directly, not through a function pointer");
4941 // Resolves `typ` by a single level if `typ` is a type variable.
4942 // If no resolution is possible, then an error is reported.
4943 // Numeric inference variables may be left unresolved.
4944 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4945 let ty = self.resolve_type_vars_with_obligations(ty);
4946 if !ty.is_ty_var() {
4949 if !self.is_tainted_by_errors() {
4950 self.need_type_info_err((**self).body_id, sp, ty)
4951 .note("type must be known at this point")
4954 self.demand_suptype(sp, self.tcx.types.err, ty);
4959 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4962 ctxt: BreakableCtxt<'tcx>,
4964 ) -> (BreakableCtxt<'tcx>, R) {
4967 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4968 index = enclosing_breakables.stack.len();
4969 enclosing_breakables.by_id.insert(id, index);
4970 enclosing_breakables.stack.push(ctxt);
4974 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4975 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4976 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4977 enclosing_breakables.stack.pop().expect("missing breakable context")
4982 /// Instantiate a QueryResponse in a probe context, without a
4983 /// good ObligationCause.
4984 fn probe_instantiate_query_response(
4987 original_values: &OriginalQueryValues<'tcx>,
4988 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4989 ) -> InferResult<'tcx, Ty<'tcx>>
4991 self.instantiate_query_response_and_region_obligations(
4992 &traits::ObligationCause::misc(span, self.body_id),
4998 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4999 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
5000 let mut contained_in_place = false;
5002 while let hir::Node::Expr(parent_expr) =
5003 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
5005 match &parent_expr.kind {
5006 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
5007 if lhs.hir_id == expr_id {
5008 contained_in_place = true;
5014 expr_id = parent_expr.hir_id;
5021 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
5022 let own_counts = generics.own_counts();
5024 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
5030 if own_counts.types == 0 {
5034 // Make a vector of booleans initially `false`; set to `true` when used.
5035 let mut types_used = vec![false; own_counts.types];
5037 for leaf_ty in ty.walk() {
5038 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.kind {
5039 debug!("found use of ty param num {}", index);
5040 types_used[index as usize - own_counts.lifetimes] = true;
5041 } else if let ty::Error = leaf_ty.kind {
5042 // If there is already another error, do not emit
5043 // an error for not using a type parameter.
5044 assert!(tcx.sess.has_errors());
5049 let types = generics.params.iter().filter(|param| match param.kind {
5050 ty::GenericParamDefKind::Type { .. } => true,
5053 for (&used, param) in types_used.iter().zip(types) {
5055 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
5056 let span = tcx.hir().span(id);
5057 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
5058 .span_label(span, "unused type parameter")
5064 fn fatally_break_rust(sess: &Session) {
5065 let handler = sess.diagnostic();
5066 handler.span_bug_no_panic(
5068 "It looks like you're trying to break rust; would you like some ICE?",
5070 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
5071 handler.note_without_error(
5072 "we would appreciate a joke overview: \
5073 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
5075 handler.note_without_error(&format!("rustc {} running on {}",
5076 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
5077 crate::session::config::host_triple(),
5081 fn potentially_plural_count(count: usize, word: &str) -> String {
5082 format!("{} {}{}", count, word, pluralise!(count))