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};
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_data_structures::indexed_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::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
120 use rustc::ty::util::{Representability, IntTypeExt, Discr};
121 use rustc::ty::layout::VariantIdx;
122 use syntax_pos::{self, BytePos, Span, MultiSpan};
123 use syntax_pos::hygiene::DesugaringKind;
126 use syntax::feature_gate::{GateIssue, emit_feature_err};
127 use syntax::source_map::{DUMMY_SP, original_sp};
128 use syntax::symbol::{kw, sym};
130 use std::cell::{Cell, RefCell, Ref, RefMut};
131 use std::collections::hash_map::Entry;
134 use std::mem::replace;
135 use std::ops::{self, Deref};
138 use crate::require_c_abi_if_c_variadic;
139 use crate::session::Session;
140 use crate::session::config::EntryFnType;
141 use crate::TypeAndSubsts;
143 use crate::util::captures::Captures;
144 use crate::util::common::{ErrorReported, indenter};
145 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
147 pub use self::Expectation::*;
148 use self::autoderef::Autoderef;
149 use self::callee::DeferredCallResolution;
150 use self::coercion::{CoerceMany, DynamicCoerceMany};
151 pub use self::compare_method::{compare_impl_method, compare_const_impl};
152 use self::method::{MethodCallee, SelfSource};
153 use self::TupleArgumentsFlag::*;
155 /// The type of a local binding, including the revealed type for anon types.
156 #[derive(Copy, Clone)]
157 pub struct LocalTy<'tcx> {
159 revealed_ty: Ty<'tcx>
162 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
163 #[derive(Copy, Clone)]
164 struct MaybeInProgressTables<'a, 'tcx> {
165 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
168 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
169 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
170 match self.maybe_tables {
171 Some(tables) => tables.borrow(),
173 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
178 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
179 match self.maybe_tables {
180 Some(tables) => tables.borrow_mut(),
182 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
188 /// Closures defined within the function. For example:
191 /// bar(move|| { ... })
194 /// Here, the function `foo()` and the closure passed to
195 /// `bar()` will each have their own `FnCtxt`, but they will
196 /// share the inherited fields.
197 pub struct Inherited<'a, 'tcx> {
198 infcx: InferCtxt<'a, 'tcx>,
200 tables: MaybeInProgressTables<'a, 'tcx>,
202 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
204 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
206 // Some additional `Sized` obligations badly affect type inference.
207 // These obligations are added in a later stage of typeck.
208 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
210 // When we process a call like `c()` where `c` is a closure type,
211 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
212 // `FnOnce` closure. In that case, we defer full resolution of the
213 // call until upvar inference can kick in and make the
214 // decision. We keep these deferred resolutions grouped by the
215 // def-id of the closure, so that once we decide, we can easily go
216 // back and process them.
217 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
219 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
221 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
223 // Opaque types found in explicit return types and their
224 // associated fresh inference variable. Writeback resolves these
225 // variables to get the concrete type, which can be used to
226 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
227 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
229 /// Each type parameter has an implicit region bound that
230 /// indicates it must outlive at least the function body (the user
231 /// may specify stronger requirements). This field indicates the
232 /// region of the callee. If it is `None`, then the parameter
233 /// environment is for an item or something where the "callee" is
235 implicit_region_bound: Option<ty::Region<'tcx>>,
237 body_id: Option<hir::BodyId>,
240 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
241 type Target = InferCtxt<'a, 'tcx>;
242 fn deref(&self) -> &Self::Target {
247 /// When type-checking an expression, we propagate downward
248 /// whatever type hint we are able in the form of an `Expectation`.
249 #[derive(Copy, Clone, Debug)]
250 pub enum Expectation<'tcx> {
251 /// We know nothing about what type this expression should have.
254 /// This expression should have the type given (or some subtype).
255 ExpectHasType(Ty<'tcx>),
257 /// This expression will be cast to the `Ty`.
258 ExpectCastableToType(Ty<'tcx>),
260 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
261 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
262 ExpectRvalueLikeUnsized(Ty<'tcx>),
265 impl<'a, 'tcx> Expectation<'tcx> {
266 // Disregard "castable to" expectations because they
267 // can lead us astray. Consider for example `if cond
268 // {22} else {c} as u8` -- if we propagate the
269 // "castable to u8" constraint to 22, it will pick the
270 // type 22u8, which is overly constrained (c might not
271 // be a u8). In effect, the problem is that the
272 // "castable to" expectation is not the tightest thing
273 // we can say, so we want to drop it in this case.
274 // The tightest thing we can say is "must unify with
275 // else branch". Note that in the case of a "has type"
276 // constraint, this limitation does not hold.
278 // If the expected type is just a type variable, then don't use
279 // an expected type. Otherwise, we might write parts of the type
280 // when checking the 'then' block which are incompatible with the
282 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
284 ExpectHasType(ety) => {
285 let ety = fcx.shallow_resolve(ety);
286 if !ety.is_ty_var() {
292 ExpectRvalueLikeUnsized(ety) => {
293 ExpectRvalueLikeUnsized(ety)
299 /// Provides an expectation for an rvalue expression given an *optional*
300 /// hint, which is not required for type safety (the resulting type might
301 /// be checked higher up, as is the case with `&expr` and `box expr`), but
302 /// is useful in determining the concrete type.
304 /// The primary use case is where the expected type is a fat pointer,
305 /// like `&[isize]`. For example, consider the following statement:
307 /// let x: &[isize] = &[1, 2, 3];
309 /// In this case, the expected type for the `&[1, 2, 3]` expression is
310 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
311 /// expectation `ExpectHasType([isize])`, that would be too strong --
312 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
313 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
314 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
315 /// which still is useful, because it informs integer literals and the like.
316 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
317 /// for examples of where this comes up,.
318 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
319 match fcx.tcx.struct_tail_without_normalization(ty).sty {
320 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
321 ExpectRvalueLikeUnsized(ty)
323 _ => ExpectHasType(ty)
327 // Resolves `expected` by a single level if it is a variable. If
328 // there is no expected type or resolution is not possible (e.g.,
329 // no constraints yet present), just returns `None`.
330 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
332 NoExpectation => NoExpectation,
333 ExpectCastableToType(t) => {
334 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
336 ExpectHasType(t) => {
337 ExpectHasType(fcx.resolve_vars_if_possible(&t))
339 ExpectRvalueLikeUnsized(t) => {
340 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
345 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
346 match self.resolve(fcx) {
347 NoExpectation => None,
348 ExpectCastableToType(ty) |
350 ExpectRvalueLikeUnsized(ty) => Some(ty),
354 /// It sometimes happens that we want to turn an expectation into
355 /// a **hard constraint** (i.e., something that must be satisfied
356 /// for the program to type-check). `only_has_type` will return
357 /// such a constraint, if it exists.
358 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
359 match self.resolve(fcx) {
360 ExpectHasType(ty) => Some(ty),
361 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
365 /// Like `only_has_type`, but instead of returning `None` if no
366 /// hard constraint exists, creates a fresh type variable.
367 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
368 self.only_has_type(fcx)
370 fcx.next_ty_var(TypeVariableOrigin {
371 kind: TypeVariableOriginKind::MiscVariable,
378 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
385 fn maybe_mut_place(m: hir::Mutability) -> Self {
387 hir::MutMutable => Needs::MutPlace,
388 hir::MutImmutable => Needs::None,
393 #[derive(Copy, Clone)]
394 pub struct UnsafetyState {
396 pub unsafety: hir::Unsafety,
397 pub unsafe_push_count: u32,
402 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
403 UnsafetyState { def, unsafety, unsafe_push_count: 0, from_fn: true }
406 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
407 match self.unsafety {
408 // If this unsafe, then if the outer function was already marked as
409 // unsafe we shouldn't attribute the unsafe'ness to the block. This
410 // way the block can be warned about instead of ignoring this
411 // extraneous block (functions are never warned about).
412 hir::Unsafety::Unsafe if self.from_fn => *self,
415 let (unsafety, def, count) = match blk.rules {
416 hir::PushUnsafeBlock(..) =>
417 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
418 hir::PopUnsafeBlock(..) =>
419 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
420 hir::UnsafeBlock(..) =>
421 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
423 (unsafety, self.def, self.unsafe_push_count),
427 unsafe_push_count: count,
434 #[derive(Debug, Copy, Clone)]
440 /// Tracks whether executing a node may exit normally (versus
441 /// return/break/panic, which "diverge", leaving dead code in their
442 /// wake). Tracked semi-automatically (through type variables marked
443 /// as diverging), with some manual adjustments for control-flow
444 /// primitives (approximating a CFG).
445 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
447 /// Potentially unknown, some cases converge,
448 /// others require a CFG to determine them.
451 /// Definitely known to diverge and therefore
452 /// not reach the next sibling or its parent.
454 /// The `Span` points to the expression
455 /// that caused us to diverge
456 /// (e.g. `return`, `break`, etc)
458 /// In some cases (e.g. a 'match' expression
459 /// where all arms diverge), we may be
460 /// able to provide a more informative
461 /// message to the user.
462 /// If this is None, a default messsage
463 /// will be generated, which is suitable
465 custom_note: Option<&'static str>
468 /// Same as `Always` but with a reachability
469 /// warning already emitted.
473 // Convenience impls for combinig `Diverges`.
475 impl ops::BitAnd for Diverges {
477 fn bitand(self, other: Self) -> Self {
478 cmp::min(self, other)
482 impl ops::BitOr for Diverges {
484 fn bitor(self, other: Self) -> Self {
485 cmp::max(self, other)
489 impl ops::BitAndAssign for Diverges {
490 fn bitand_assign(&mut self, other: Self) {
491 *self = *self & other;
495 impl ops::BitOrAssign for Diverges {
496 fn bitor_assign(&mut self, other: Self) {
497 *self = *self | other;
502 fn always(self) -> bool {
503 // Enum comparison ignores the
504 // contents of fields, so we just
505 // fill them in with garbage here
506 self >= Diverges::Always {
513 pub struct BreakableCtxt<'tcx> {
516 // this is `null` for loops where break with a value is illegal,
517 // such as `while`, `for`, and `while let`
518 coerce: Option<DynamicCoerceMany<'tcx>>,
521 pub struct EnclosingBreakables<'tcx> {
522 stack: Vec<BreakableCtxt<'tcx>>,
523 by_id: HirIdMap<usize>,
526 impl<'tcx> EnclosingBreakables<'tcx> {
527 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
528 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
529 bug!("could not find enclosing breakable with id {}", target_id);
535 pub struct FnCtxt<'a, 'tcx> {
538 /// The parameter environment used for proving trait obligations
539 /// in this function. This can change when we descend into
540 /// closures (as they bring new things into scope), hence it is
541 /// not part of `Inherited` (as of the time of this writing,
542 /// closures do not yet change the environment, but they will
544 param_env: ty::ParamEnv<'tcx>,
546 /// Number of errors that had been reported when we started
547 /// checking this function. On exit, if we find that *more* errors
548 /// have been reported, we will skip regionck and other work that
549 /// expects the types within the function to be consistent.
550 // FIXME(matthewjasper) This should not exist, and it's not correct
551 // if type checking is run in parallel.
552 err_count_on_creation: usize,
554 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
555 ret_coercion_span: RefCell<Option<Span>>,
557 yield_ty: Option<Ty<'tcx>>,
559 ps: RefCell<UnsafetyState>,
561 /// Whether the last checked node generates a divergence (e.g.,
562 /// `return` will set this to `Always`). In general, when entering
563 /// an expression or other node in the tree, the initial value
564 /// indicates whether prior parts of the containing expression may
565 /// have diverged. It is then typically set to `Maybe` (and the
566 /// old value remembered) for processing the subparts of the
567 /// current expression. As each subpart is processed, they may set
568 /// the flag to `Always`, etc. Finally, at the end, we take the
569 /// result and "union" it with the original value, so that when we
570 /// return the flag indicates if any subpart of the parent
571 /// expression (up to and including this part) has diverged. So,
572 /// if you read it after evaluating a subexpression `X`, the value
573 /// you get indicates whether any subexpression that was
574 /// evaluating up to and including `X` diverged.
576 /// We currently use this flag only for diagnostic purposes:
578 /// - To warn about unreachable code: if, after processing a
579 /// sub-expression but before we have applied the effects of the
580 /// current node, we see that the flag is set to `Always`, we
581 /// can issue a warning. This corresponds to something like
582 /// `foo(return)`; we warn on the `foo()` expression. (We then
583 /// update the flag to `WarnedAlways` to suppress duplicate
584 /// reports.) Similarly, if we traverse to a fresh statement (or
585 /// tail expression) from a `Always` setting, we will issue a
586 /// warning. This corresponds to something like `{return;
587 /// foo();}` or `{return; 22}`, where we would warn on the
590 /// An expression represents dead code if, after checking it,
591 /// the diverges flag is set to something other than `Maybe`.
592 diverges: Cell<Diverges>,
594 /// Whether any child nodes have any type errors.
595 has_errors: Cell<bool>,
597 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
599 inh: &'a Inherited<'a, 'tcx>,
602 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
603 type Target = Inherited<'a, 'tcx>;
604 fn deref(&self) -> &Self::Target {
609 /// Helper type of a temporary returned by `Inherited::build(...)`.
610 /// Necessary because we can't write the following bound:
611 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
612 pub struct InheritedBuilder<'tcx> {
613 infcx: infer::InferCtxtBuilder<'tcx>,
617 impl Inherited<'_, 'tcx> {
618 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
619 let hir_id_root = if def_id.is_local() {
620 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
621 DefId::local(hir_id.owner)
627 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
633 impl<'tcx> InheritedBuilder<'tcx> {
634 fn enter<F, R>(&mut self, f: F) -> R
636 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
638 let def_id = self.def_id;
639 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
643 impl Inherited<'a, 'tcx> {
644 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
646 let item_id = tcx.hir().as_local_hir_id(def_id);
647 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
648 let implicit_region_bound = body_id.map(|body_id| {
649 let body = tcx.hir().body(body_id);
650 tcx.mk_region(ty::ReScope(region::Scope {
651 id: body.value.hir_id.local_id,
652 data: region::ScopeData::CallSite
657 tables: MaybeInProgressTables {
658 maybe_tables: infcx.in_progress_tables,
661 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
662 locals: RefCell::new(Default::default()),
663 deferred_sized_obligations: RefCell::new(Vec::new()),
664 deferred_call_resolutions: RefCell::new(Default::default()),
665 deferred_cast_checks: RefCell::new(Vec::new()),
666 deferred_generator_interiors: RefCell::new(Vec::new()),
667 opaque_types: RefCell::new(Default::default()),
668 implicit_region_bound,
673 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
674 debug!("register_predicate({:?})", obligation);
675 if obligation.has_escaping_bound_vars() {
676 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
681 .register_predicate_obligation(self, obligation);
684 fn register_predicates<I>(&self, obligations: I)
685 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
687 for obligation in obligations {
688 self.register_predicate(obligation);
692 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
693 self.register_predicates(infer_ok.obligations);
697 fn normalize_associated_types_in<T>(&self,
700 param_env: ty::ParamEnv<'tcx>,
702 where T : TypeFoldable<'tcx>
704 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
705 self.register_infer_ok_obligations(ok)
709 struct CheckItemTypesVisitor<'tcx> {
713 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
714 fn visit_item(&mut self, i: &'tcx hir::Item) {
715 check_item_type(self.tcx, i);
717 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
718 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
721 pub fn check_wf_new(tcx: TyCtxt<'_>) {
722 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
723 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
726 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
727 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
730 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
731 debug_assert!(crate_num == LOCAL_CRATE);
732 tcx.par_body_owners(|body_owner_def_id| {
733 tcx.ensure().typeck_tables_of(body_owner_def_id);
737 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
738 wfcheck::check_item_well_formed(tcx, def_id);
741 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
742 wfcheck::check_trait_item(tcx, def_id);
745 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
746 wfcheck::check_impl_item(tcx, def_id);
749 pub fn provide(providers: &mut Providers<'_>) {
750 method::provide(providers);
751 *providers = Providers {
757 check_item_well_formed,
758 check_trait_item_well_formed,
759 check_impl_item_well_formed,
760 check_mod_item_types,
765 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
766 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
769 /// If this `DefId` is a "primary tables entry", returns
770 /// `Some((body_id, header, decl))` with information about
771 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
774 /// If this function returns `Some`, then `typeck_tables(def_id)` will
775 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
776 /// may not succeed. In some cases where this function returns `None`
777 /// (notably closures), `typeck_tables(def_id)` would wind up
778 /// redirecting to the owning function.
782 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
783 match tcx.hir().get(id) {
784 Node::Item(item) => {
786 hir::ItemKind::Const(ref ty, body) |
787 hir::ItemKind::Static(ref ty, _, body) =>
788 Some((body, Some(ty), None, None)),
789 hir::ItemKind::Fn(ref decl, ref header, .., body) =>
790 Some((body, None, Some(header), Some(decl))),
795 Node::TraitItem(item) => {
797 hir::TraitItemKind::Const(ref ty, Some(body)) =>
798 Some((body, Some(ty), None, None)),
799 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
800 Some((body, None, Some(&sig.header), Some(&sig.decl))),
805 Node::ImplItem(item) => {
807 hir::ImplItemKind::Const(ref ty, body) =>
808 Some((body, Some(ty), None, None)),
809 hir::ImplItemKind::Method(ref sig, body) =>
810 Some((body, None, Some(&sig.header), Some(&sig.decl))),
815 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
820 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
821 // Closures' tables come from their outermost function,
822 // as they are part of the same "inference environment".
823 let outer_def_id = tcx.closure_base_def_id(def_id);
824 if outer_def_id != def_id {
825 return tcx.has_typeck_tables(outer_def_id);
828 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
829 primary_body_of(tcx, id).is_some()
832 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
833 &*tcx.typeck_tables_of(def_id).used_trait_imports
836 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
837 // Closures' tables come from their outermost function,
838 // as they are part of the same "inference environment".
839 let outer_def_id = tcx.closure_base_def_id(def_id);
840 if outer_def_id != def_id {
841 return tcx.typeck_tables_of(outer_def_id);
844 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
845 let span = tcx.hir().span(id);
847 // Figure out what primary body this item has.
848 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
850 span_bug!(span, "can't type-check body of {:?}", def_id);
852 let body = tcx.hir().body(body_id);
854 let tables = Inherited::build(tcx, def_id).enter(|inh| {
855 let param_env = tcx.param_env(def_id);
856 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
857 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
858 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
859 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
864 check_abi(tcx, span, fn_sig.abi());
866 // Compute the fty from point of view of inside the fn.
868 tcx.liberate_late_bound_regions(def_id, &fn_sig);
870 inh.normalize_associated_types_in(body.value.span,
875 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
878 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
879 let expected_type = body_ty.and_then(|ty| match ty.node {
880 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
882 }).unwrap_or_else(|| tcx.type_of(def_id));
883 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
884 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
886 let revealed_ty = if tcx.features().impl_trait_in_bindings {
887 fcx.instantiate_opaque_types_from_value(
896 // Gather locals in statics (because of block expressions).
897 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
899 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
901 fcx.write_ty(id, revealed_ty);
906 // All type checking constraints were added, try to fallback unsolved variables.
907 fcx.select_obligations_where_possible(false);
908 let mut fallback_has_occurred = false;
909 for ty in &fcx.unsolved_variables() {
910 fallback_has_occurred |= fcx.fallback_if_possible(ty);
912 fcx.select_obligations_where_possible(fallback_has_occurred);
914 // Even though coercion casts provide type hints, we check casts after fallback for
915 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
918 // Closure and generator analysis may run after fallback
919 // because they don't constrain other type variables.
920 fcx.closure_analyze(body);
921 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
922 fcx.resolve_generator_interiors(def_id);
924 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
925 let ty = fcx.normalize_ty(span, ty);
926 fcx.require_type_is_sized(ty, span, code);
928 fcx.select_all_obligations_or_error();
930 if fn_decl.is_some() {
931 fcx.regionck_fn(id, body);
933 fcx.regionck_expr(body);
936 fcx.resolve_type_vars_in_body(body)
939 // Consistency check our TypeckTables instance can hold all ItemLocalIds
940 // it will need to hold.
941 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
946 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
947 if !tcx.sess.target.target.is_abi_supported(abi) {
948 struct_span_err!(tcx.sess, span, E0570,
949 "The ABI `{}` is not supported for the current target", abi).emit()
953 struct GatherLocalsVisitor<'a, 'tcx> {
954 fcx: &'a FnCtxt<'a, 'tcx>,
955 parent_id: hir::HirId,
958 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
959 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
962 // infer the variable's type
963 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
964 kind: TypeVariableOriginKind::TypeInference,
967 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
974 // take type that the user specified
975 self.fcx.locals.borrow_mut().insert(nid, typ);
982 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
983 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
984 NestedVisitorMap::None
987 // Add explicitly-declared locals.
988 fn visit_local(&mut self, local: &'tcx hir::Local) {
989 let local_ty = match local.ty {
991 let o_ty = self.fcx.to_ty(&ty);
993 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
994 self.fcx.instantiate_opaque_types_from_value(
1003 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
1004 &UserType::Ty(revealed_ty)
1006 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
1007 ty.hir_id, o_ty, revealed_ty, c_ty);
1008 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
1010 Some(LocalTy { decl_ty: o_ty, revealed_ty })
1014 self.assign(local.span, local.hir_id, local_ty);
1016 debug!("local variable {:?} is assigned type {}",
1018 self.fcx.ty_to_string(
1019 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1020 intravisit::walk_local(self, local);
1023 // Add pattern bindings.
1024 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1025 if let PatKind::Binding(_, _, ident, _) = p.node {
1026 let var_ty = self.assign(p.span, p.hir_id, None);
1028 if !self.fcx.tcx.features().unsized_locals {
1029 self.fcx.require_type_is_sized(var_ty, p.span,
1030 traits::VariableType(p.hir_id));
1033 debug!("pattern binding {} is assigned to {} with type {:?}",
1035 self.fcx.ty_to_string(
1036 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1039 intravisit::walk_pat(self, p);
1042 // Don't descend into the bodies of nested closures
1045 _: intravisit::FnKind<'tcx>,
1046 _: &'tcx hir::FnDecl,
1053 /// When `check_fn` is invoked on a generator (i.e., a body that
1054 /// includes yield), it returns back some information about the yield
1056 struct GeneratorTypes<'tcx> {
1057 /// Type of value that is yielded.
1060 /// Types that are captured (see `GeneratorInterior` for more).
1063 /// Indicates if the generator is movable or static (immovable).
1064 movability: hir::GeneratorMovability,
1067 /// Helper used for fns and closures. Does the grungy work of checking a function
1068 /// body and returns the function context used for that purpose, since in the case of a fn item
1069 /// there is still a bit more to do.
1072 /// * inherited: other fields inherited from the enclosing fn (if any)
1073 fn check_fn<'a, 'tcx>(
1074 inherited: &'a Inherited<'a, 'tcx>,
1075 param_env: ty::ParamEnv<'tcx>,
1076 fn_sig: ty::FnSig<'tcx>,
1077 decl: &'tcx hir::FnDecl,
1079 body: &'tcx hir::Body,
1080 can_be_generator: Option<hir::GeneratorMovability>,
1081 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1082 let mut fn_sig = fn_sig.clone();
1084 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1086 // Create the function context. This is either derived from scratch or,
1087 // in the case of closures, based on the outer context.
1088 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1089 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1091 let declared_ret_ty = fn_sig.output();
1092 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1093 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1098 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1099 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1100 fn_sig = fcx.tcx.mk_fn_sig(
1101 fn_sig.inputs().iter().cloned(),
1108 let span = body.value.span;
1110 fn_maybe_err(fcx.tcx, span, fn_sig.abi);
1112 if body.generator_kind.is_some() && can_be_generator.is_some() {
1113 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1114 kind: TypeVariableOriginKind::TypeInference,
1117 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1118 fcx.yield_ty = Some(yield_ty);
1121 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1122 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1123 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1125 // Add formal parameters.
1126 for (param_ty, param) in fn_sig.inputs().iter().zip(&body.params) {
1127 // Check the pattern.
1128 fcx.check_pat_top(¶m.pat, param_ty, None);
1130 // Check that argument is Sized.
1131 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1132 // for simple cases like `fn foo(x: Trait)`,
1133 // where we would error once on the parameter as a whole, and once on the binding `x`.
1134 if param.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1135 fcx.require_type_is_sized(param_ty, decl.output.span(), traits::SizedArgumentType);
1138 fcx.write_ty(param.hir_id, param_ty);
1141 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1143 fcx.check_return_expr(&body.value);
1145 // We insert the deferred_generator_interiors entry after visiting the body.
1146 // This ensures that all nested generators appear before the entry of this generator.
1147 // resolve_generator_interiors relies on this property.
1148 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1149 let interior = fcx.next_ty_var(TypeVariableOrigin {
1150 kind: TypeVariableOriginKind::MiscVariable,
1153 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1154 Some(GeneratorTypes {
1155 yield_ty: fcx.yield_ty.unwrap(),
1157 movability: can_be_generator.unwrap(),
1163 // Finalize the return check by taking the LUB of the return types
1164 // we saw and assigning it to the expected return type. This isn't
1165 // really expected to fail, since the coercions would have failed
1166 // earlier when trying to find a LUB.
1168 // However, the behavior around `!` is sort of complex. In the
1169 // event that the `actual_return_ty` comes back as `!`, that
1170 // indicates that the fn either does not return or "returns" only
1171 // values of type `!`. In this case, if there is an expected
1172 // return type that is *not* `!`, that should be ok. But if the
1173 // return type is being inferred, we want to "fallback" to `!`:
1175 // let x = move || panic!();
1177 // To allow for that, I am creating a type variable with diverging
1178 // fallback. This was deemed ever so slightly better than unifying
1179 // the return value with `!` because it allows for the caller to
1180 // make more assumptions about the return type (e.g., they could do
1182 // let y: Option<u32> = Some(x());
1184 // which would then cause this return type to become `u32`, not
1186 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1187 let mut actual_return_ty = coercion.complete(&fcx);
1188 if actual_return_ty.is_never() {
1189 actual_return_ty = fcx.next_diverging_ty_var(
1190 TypeVariableOrigin {
1191 kind: TypeVariableOriginKind::DivergingFn,
1196 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1198 // Check that the main return type implements the termination trait.
1199 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1200 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1201 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1202 if main_id == fn_id {
1203 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1204 let trait_ref = ty::TraitRef::new(term_id, substs);
1205 let return_ty_span = decl.output.span();
1206 let cause = traits::ObligationCause::new(
1207 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1209 inherited.register_predicate(
1210 traits::Obligation::new(
1211 cause, param_env, trait_ref.to_predicate()));
1216 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1217 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1218 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1219 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1220 // at this point we don't care if there are duplicate handlers or if the handler has
1221 // the wrong signature as this value we'll be used when writing metadata and that
1222 // only happens if compilation succeeded
1223 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1225 if declared_ret_ty.sty != ty::Never {
1226 fcx.tcx.sess.span_err(
1228 "return type should be `!`",
1232 let inputs = fn_sig.inputs();
1233 let span = fcx.tcx.hir().span(fn_id);
1234 if inputs.len() == 1 {
1235 let arg_is_panic_info = match inputs[0].sty {
1236 ty::Ref(region, ty, mutbl) => match ty.sty {
1237 ty::Adt(ref adt, _) => {
1238 adt.did == panic_info_did &&
1239 mutbl == hir::Mutability::MutImmutable &&
1240 *region != RegionKind::ReStatic
1247 if !arg_is_panic_info {
1248 fcx.tcx.sess.span_err(
1249 decl.inputs[0].span,
1250 "argument should be `&PanicInfo`",
1254 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1255 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1256 if !generics.params.is_empty() {
1257 fcx.tcx.sess.span_err(
1259 "should have no type parameters",
1265 let span = fcx.tcx.sess.source_map().def_span(span);
1266 fcx.tcx.sess.span_err(span, "function should have one argument");
1269 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1274 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1275 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1276 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1277 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1278 if declared_ret_ty.sty != ty::Never {
1279 fcx.tcx.sess.span_err(
1281 "return type should be `!`",
1285 let inputs = fn_sig.inputs();
1286 let span = fcx.tcx.hir().span(fn_id);
1287 if inputs.len() == 1 {
1288 let arg_is_alloc_layout = match inputs[0].sty {
1289 ty::Adt(ref adt, _) => {
1290 adt.did == alloc_layout_did
1295 if !arg_is_alloc_layout {
1296 fcx.tcx.sess.span_err(
1297 decl.inputs[0].span,
1298 "argument should be `Layout`",
1302 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1303 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1304 if !generics.params.is_empty() {
1305 fcx.tcx.sess.span_err(
1307 "`#[alloc_error_handler]` function should have no type \
1314 let span = fcx.tcx.sess.source_map().def_span(span);
1315 fcx.tcx.sess.span_err(span, "function should have one argument");
1318 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1326 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1327 let def_id = tcx.hir().local_def_id(id);
1328 let def = tcx.adt_def(def_id);
1329 def.destructor(tcx); // force the destructor to be evaluated
1330 check_representable(tcx, span, def_id);
1332 if def.repr.simd() {
1333 check_simd(tcx, span, def_id);
1336 check_transparent(tcx, span, def_id);
1337 check_packed(tcx, span, def_id);
1340 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1341 let def_id = tcx.hir().local_def_id(id);
1342 let def = tcx.adt_def(def_id);
1343 def.destructor(tcx); // force the destructor to be evaluated
1344 check_representable(tcx, span, def_id);
1345 check_transparent(tcx, span, def_id);
1346 check_packed(tcx, span, def_id);
1349 /// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
1350 /// projections that would result in "inheriting lifetimes".
1351 fn check_opaque<'tcx>(
1354 substs: SubstsRef<'tcx>,
1356 origin: &hir::OpaqueTyOrigin,
1358 check_opaque_for_inheriting_lifetimes(tcx, def_id, span);
1359 check_opaque_for_cycles(tcx, def_id, substs, span, origin);
1362 /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
1363 /// in "inheriting lifetimes".
1364 fn check_opaque_for_inheriting_lifetimes(
1369 let item = tcx.hir().expect_item(
1370 tcx.hir().as_local_hir_id(def_id).expect("opaque type is not local"));
1371 debug!("check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}",
1372 def_id, span, item);
1375 struct ProhibitOpaqueVisitor<'tcx> {
1376 opaque_identity_ty: Ty<'tcx>,
1377 generics: &'tcx ty::Generics,
1380 impl<'tcx> ty::fold::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
1381 fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
1382 debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
1383 if t == self.opaque_identity_ty { false } else { t.super_visit_with(self) }
1386 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
1387 debug!("check_opaque_for_inheriting_lifetimes: (visit_region) r={:?}", r);
1388 if let RegionKind::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = r {
1389 return *index < self.generics.parent_count as u32;
1392 r.super_visit_with(self)
1396 let prohibit_opaque = match item.node {
1397 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::AsyncFn, .. }) |
1398 ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn, .. }) => {
1399 let mut visitor = ProhibitOpaqueVisitor {
1400 opaque_identity_ty: tcx.mk_opaque(
1401 def_id, InternalSubsts::identity_for_item(tcx, def_id)),
1402 generics: tcx.generics_of(def_id),
1404 debug!("check_opaque_for_inheriting_lifetimes: visitor={:?}", visitor);
1406 tcx.predicates_of(def_id).predicates.iter().any(
1407 |(predicate, _)| predicate.visit_with(&mut visitor))
1412 debug!("check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}", prohibit_opaque);
1413 if prohibit_opaque {
1414 let is_async = match item.node {
1415 ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => match origin {
1416 hir::OpaqueTyOrigin::AsyncFn => true,
1419 _ => unreachable!(),
1422 tcx.sess.span_err(span, &format!(
1423 "`{}` return type cannot contain a projection or `Self` that references lifetimes from \
1425 if is_async { "async fn" } else { "impl Trait" },
1430 /// Checks that an opaque type does not contain cycles.
1431 fn check_opaque_for_cycles<'tcx>(
1434 substs: SubstsRef<'tcx>,
1436 origin: &hir::OpaqueTyOrigin,
1438 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1439 if let hir::OpaqueTyOrigin::AsyncFn = origin {
1441 tcx.sess, span, E0733,
1442 "recursion in an `async fn` requires boxing",
1444 .span_label(span, "recursive `async fn`")
1445 .note("a recursive `async fn` must be rewritten to return a boxed `dyn Future`.")
1448 let mut err = struct_span_err!(
1449 tcx.sess, span, E0720,
1450 "opaque type expands to a recursive type",
1452 err.span_label(span, "expands to a recursive type");
1453 if let ty::Opaque(..) = partially_expanded_type.sty {
1454 err.note("type resolves to itself");
1456 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1463 // Forbid defining intrinsics in Rust code,
1464 // as they must always be defined by the compiler.
1465 fn fn_maybe_err(tcx: TyCtxt<'_>, sp: Span, abi: Abi) {
1466 if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = abi {
1467 tcx.sess.span_err(sp, "intrinsic must be in `extern \"rust-intrinsic\" { ... }` block");
1471 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1473 "check_item_type(it.hir_id={}, it.name={})",
1475 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1477 let _indenter = indenter();
1479 // Consts can play a role in type-checking, so they are included here.
1480 hir::ItemKind::Static(..) => {
1481 let def_id = tcx.hir().local_def_id(it.hir_id);
1482 tcx.typeck_tables_of(def_id);
1483 maybe_check_static_with_link_section(tcx, def_id, it.span);
1485 hir::ItemKind::Const(..) => {
1486 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1488 hir::ItemKind::Enum(ref enum_definition, _) => {
1489 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1491 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1492 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1493 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1494 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1495 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1496 check_impl_items_against_trait(
1503 let trait_def_id = impl_trait_ref.def_id;
1504 check_on_unimplemented(tcx, trait_def_id, it);
1507 hir::ItemKind::Trait(_, _, _, _, ref items) => {
1508 let def_id = tcx.hir().local_def_id(it.hir_id);
1509 check_on_unimplemented(tcx, def_id, it);
1511 for item in items.iter() {
1512 let item = tcx.hir().trait_item(item.id);
1513 if let hir::TraitItemKind::Method(sig, _) = &item.node {
1514 let abi = sig.header.abi;
1515 fn_maybe_err(tcx, item.ident.span, abi);
1519 hir::ItemKind::Struct(..) => {
1520 check_struct(tcx, it.hir_id, it.span);
1522 hir::ItemKind::Union(..) => {
1523 check_union(tcx, it.hir_id, it.span);
1525 hir::ItemKind::OpaqueTy(hir::OpaqueTy{origin, ..}) => {
1526 let def_id = tcx.hir().local_def_id(it.hir_id);
1528 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1529 check_opaque(tcx, def_id, substs, it.span, &origin);
1531 hir::ItemKind::TyAlias(..) => {
1532 let def_id = tcx.hir().local_def_id(it.hir_id);
1533 let pty_ty = tcx.type_of(def_id);
1534 let generics = tcx.generics_of(def_id);
1535 check_bounds_are_used(tcx, &generics, pty_ty);
1537 hir::ItemKind::ForeignMod(ref m) => {
1538 check_abi(tcx, it.span, m.abi);
1540 if m.abi == Abi::RustIntrinsic {
1541 for item in &m.items {
1542 intrinsic::check_intrinsic_type(tcx, item);
1544 } else if m.abi == Abi::PlatformIntrinsic {
1545 for item in &m.items {
1546 intrinsic::check_platform_intrinsic_type(tcx, item);
1549 for item in &m.items {
1550 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1551 let own_counts = generics.own_counts();
1552 if generics.params.len() - own_counts.lifetimes != 0 {
1553 let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
1554 (_, 0) => ("type", "types", Some("u32")),
1555 // We don't specify an example value, because we can't generate
1556 // a valid value for any type.
1557 (0, _) => ("const", "consts", None),
1558 _ => ("type or const", "types or consts", None),
1564 "foreign items may not have {} parameters",
1568 &format!("can't have {} parameters", kinds),
1570 // FIXME: once we start storing spans for type arguments, turn this
1571 // into a suggestion.
1573 "replace the {} parameters with concrete {}{}",
1576 egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
1581 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1582 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1587 _ => { /* nothing to do */ }
1591 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1592 // Only restricted on wasm32 target for now
1593 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1597 // If `#[link_section]` is missing, then nothing to verify
1598 let attrs = tcx.codegen_fn_attrs(id);
1599 if attrs.link_section.is_none() {
1603 // For the wasm32 target statics with `#[link_section]` are placed into custom
1604 // sections of the final output file, but this isn't link custom sections of
1605 // other executable formats. Namely we can only embed a list of bytes,
1606 // nothing with pointers to anything else or relocations. If any relocation
1607 // show up, reject them here.
1608 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1609 // the consumer's responsibility to ensure all bytes that have been read
1610 // have defined values.
1611 let instance = ty::Instance::mono(tcx, id);
1612 let cid = GlobalId {
1616 let param_env = ty::ParamEnv::reveal_all();
1617 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1618 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1621 bug!("Matching on non-ByRef static")
1623 if alloc.relocations().len() != 0 {
1624 let msg = "statics with a custom `#[link_section]` must be a \
1625 simple list of bytes on the wasm target with no \
1626 extra levels of indirection such as references";
1627 tcx.sess.span_err(span, msg);
1632 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1633 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1634 // an error would be reported if this fails.
1635 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1638 fn report_forbidden_specialization(
1640 impl_item: &hir::ImplItem,
1643 let mut err = struct_span_err!(
1644 tcx.sess, impl_item.span, E0520,
1645 "`{}` specializes an item from a parent `impl`, but \
1646 that item is not marked `default`",
1648 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1651 match tcx.span_of_impl(parent_impl) {
1653 err.span_label(span, "parent `impl` is here");
1654 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1658 err.note(&format!("parent implementation is in crate `{}`", cname));
1665 fn check_specialization_validity<'tcx>(
1667 trait_def: &ty::TraitDef,
1668 trait_item: &ty::AssocItem,
1670 impl_item: &hir::ImplItem,
1672 let ancestors = trait_def.ancestors(tcx, impl_id);
1674 let kind = match impl_item.node {
1675 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1676 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1677 hir::ImplItemKind::OpaqueTy(..) => ty::AssocKind::OpaqueTy,
1678 hir::ImplItemKind::TyAlias(_) => ty::AssocKind::Type,
1681 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1682 .map(|node_item| node_item.map(|parent| parent.defaultness));
1684 if let Some(parent) = parent {
1685 if tcx.impl_item_is_final(&parent) {
1686 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1692 fn check_impl_items_against_trait<'tcx>(
1696 impl_trait_ref: ty::TraitRef<'tcx>,
1697 impl_item_refs: &[hir::ImplItemRef],
1699 let impl_span = tcx.sess.source_map().def_span(impl_span);
1701 // If the trait reference itself is erroneous (so the compilation is going
1702 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1703 // isn't populated for such impls.
1704 if impl_trait_ref.references_error() { return; }
1706 // Locate trait definition and items
1707 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1708 let mut overridden_associated_type = None;
1710 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1712 // Check existing impl methods to see if they are both present in trait
1713 // and compatible with trait signature
1714 for impl_item in impl_items() {
1715 let ty_impl_item = tcx.associated_item(
1716 tcx.hir().local_def_id(impl_item.hir_id));
1717 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1718 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1719 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1721 // Not compatible, but needed for the error message
1722 tcx.associated_items(impl_trait_ref.def_id)
1723 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1726 // Check that impl definition matches trait definition
1727 if let Some(ty_trait_item) = ty_trait_item {
1728 match impl_item.node {
1729 hir::ImplItemKind::Const(..) => {
1730 // Find associated const definition.
1731 if ty_trait_item.kind == ty::AssocKind::Const {
1732 compare_const_impl(tcx,
1738 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1739 "item `{}` is an associated const, \
1740 which doesn't match its trait `{}`",
1743 err.span_label(impl_item.span, "does not match trait");
1744 // We can only get the spans from local trait definition
1745 // Same for E0324 and E0325
1746 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1747 err.span_label(trait_span, "item in trait");
1752 hir::ImplItemKind::Method(..) => {
1753 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1754 if ty_trait_item.kind == ty::AssocKind::Method {
1755 compare_impl_method(tcx,
1762 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1763 "item `{}` is an associated method, \
1764 which doesn't match its trait `{}`",
1767 err.span_label(impl_item.span, "does not match trait");
1768 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1769 err.span_label(trait_span, "item in trait");
1774 hir::ImplItemKind::OpaqueTy(..) |
1775 hir::ImplItemKind::TyAlias(_) => {
1776 if ty_trait_item.kind == ty::AssocKind::Type {
1777 if ty_trait_item.defaultness.has_value() {
1778 overridden_associated_type = Some(impl_item);
1781 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1782 "item `{}` is an associated type, \
1783 which doesn't match its trait `{}`",
1786 err.span_label(impl_item.span, "does not match trait");
1787 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1788 err.span_label(trait_span, "item in trait");
1795 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1799 // Check for missing items from trait
1800 let mut missing_items = Vec::new();
1801 let mut invalidated_items = Vec::new();
1802 let associated_type_overridden = overridden_associated_type.is_some();
1803 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1804 let is_implemented = trait_def.ancestors(tcx, impl_id)
1805 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1807 .map(|node_item| !node_item.node.is_from_trait())
1810 if !is_implemented && !tcx.impl_is_default(impl_id) {
1811 if !trait_item.defaultness.has_value() {
1812 missing_items.push(trait_item);
1813 } else if associated_type_overridden {
1814 invalidated_items.push(trait_item.ident);
1819 if !missing_items.is_empty() {
1820 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1821 "not all trait items implemented, missing: `{}`",
1822 missing_items.iter()
1823 .map(|trait_item| trait_item.ident.to_string())
1824 .collect::<Vec<_>>().join("`, `"));
1825 err.span_label(impl_span, format!("missing `{}` in implementation",
1826 missing_items.iter()
1827 .map(|trait_item| trait_item.ident.to_string())
1828 .collect::<Vec<_>>().join("`, `")));
1829 for trait_item in missing_items {
1830 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1831 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1833 err.note_trait_signature(trait_item.ident.to_string(),
1834 trait_item.signature(tcx));
1840 if !invalidated_items.is_empty() {
1841 let invalidator = overridden_associated_type.unwrap();
1842 span_err!(tcx.sess, invalidator.span, E0399,
1843 "the following trait items need to be reimplemented \
1844 as `{}` was overridden: `{}`",
1846 invalidated_items.iter()
1847 .map(|name| name.to_string())
1848 .collect::<Vec<_>>().join("`, `"))
1852 /// Checks whether a type can be represented in memory. In particular, it
1853 /// identifies types that contain themselves without indirection through a
1854 /// pointer, which would mean their size is unbounded.
1855 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1856 let rty = tcx.type_of(item_def_id);
1858 // Check that it is possible to represent this type. This call identifies
1859 // (1) types that contain themselves and (2) types that contain a different
1860 // recursive type. It is only necessary to throw an error on those that
1861 // contain themselves. For case 2, there must be an inner type that will be
1862 // caught by case 1.
1863 match rty.is_representable(tcx, sp) {
1864 Representability::SelfRecursive(spans) => {
1865 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1867 err.span_label(span, "recursive without indirection");
1872 Representability::Representable | Representability::ContainsRecursive => (),
1877 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1878 let t = tcx.type_of(def_id);
1879 if let ty::Adt(def, substs) = t.sty {
1880 if def.is_struct() {
1881 let fields = &def.non_enum_variant().fields;
1882 if fields.is_empty() {
1883 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1886 let e = fields[0].ty(tcx, substs);
1887 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1888 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1889 .span_label(sp, "SIMD elements must have the same type")
1894 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1895 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1897 span_err!(tcx.sess, sp, E0077,
1898 "SIMD vector element type should be machine type");
1906 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1907 let repr = tcx.adt_def(def_id).repr;
1909 for attr in tcx.get_attrs(def_id).iter() {
1910 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1911 if let attr::ReprPacked(pack) = r {
1912 if let Some(repr_pack) = repr.pack {
1913 if pack as u64 != repr_pack.bytes() {
1915 tcx.sess, sp, E0634,
1916 "type has conflicting packed representation hints"
1923 if repr.align.is_some() {
1924 struct_span_err!(tcx.sess, sp, E0587,
1925 "type has conflicting packed and align representation hints").emit();
1927 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1928 struct_span_err!(tcx.sess, sp, E0588,
1929 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1934 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1935 let t = tcx.type_of(def_id);
1936 if stack.contains(&def_id) {
1937 debug!("check_packed_inner: {:?} is recursive", t);
1940 if let ty::Adt(def, substs) = t.sty {
1941 if def.is_struct() || def.is_union() {
1942 if tcx.adt_def(def.did).repr.align.is_some() {
1945 // push struct def_id before checking fields
1947 for field in &def.non_enum_variant().fields {
1948 let f = field.ty(tcx, substs);
1949 if let ty::Adt(def, _) = f.sty {
1950 if check_packed_inner(tcx, def.did, stack) {
1955 // only need to pop if not early out
1962 /// Emit an error when encountering more or less than one variant in a transparent enum.
1963 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1964 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1965 tcx.hir().span_if_local(variant.def_id).unwrap()
1968 "needs exactly one variant, but has {}",
1971 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1972 err.span_label(sp, &msg);
1973 if let &[ref start @ .., ref end] = &variant_spans[..] {
1974 for variant_span in start {
1975 err.span_label(*variant_span, "");
1977 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1982 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1984 fn bad_non_zero_sized_fields<'tcx>(
1986 adt: &'tcx ty::AdtDef,
1988 field_spans: impl Iterator<Item = Span>,
1991 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1992 let mut err = struct_span_err!(
1996 "{}transparent {} {}",
1997 if adt.is_enum() { "the variant of a " } else { "" },
2001 err.span_label(sp, &msg);
2002 for sp in field_spans {
2003 err.span_label(sp, "this field is non-zero-sized");
2008 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
2009 let adt = tcx.adt_def(def_id);
2010 if !adt.repr.transparent() {
2013 let sp = tcx.sess.source_map().def_span(sp);
2016 if !tcx.features().transparent_enums {
2018 &tcx.sess.parse_sess,
2019 sym::transparent_enums,
2021 GateIssue::Language,
2022 "transparent enums are unstable",
2025 if adt.variants.len() != 1 {
2026 bad_variant_count(tcx, adt, sp, def_id);
2027 if adt.variants.is_empty() {
2028 // Don't bother checking the fields. No variants (and thus no fields) exist.
2034 if adt.is_union() && !tcx.features().transparent_unions {
2035 emit_feature_err(&tcx.sess.parse_sess,
2036 sym::transparent_unions,
2038 GateIssue::Language,
2039 "transparent unions are unstable");
2042 // For each field, figure out if it's known to be a ZST and align(1)
2043 let field_infos = adt.all_fields().map(|field| {
2044 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
2045 let param_env = tcx.param_env(field.did);
2046 let layout = tcx.layout_of(param_env.and(ty));
2047 // We are currently checking the type this field came from, so it must be local
2048 let span = tcx.hir().span_if_local(field.did).unwrap();
2049 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
2050 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
2054 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
2059 let non_zst_count = non_zst_fields.clone().count();
2060 if non_zst_count != 1 {
2061 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
2063 for (span, zst, align1) in field_infos {
2069 "zero-sized field in transparent {} has alignment larger than 1",
2071 ).span_label(span, "has alignment larger than 1").emit();
2076 #[allow(trivial_numeric_casts)]
2077 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
2078 let def_id = tcx.hir().local_def_id(id);
2079 let def = tcx.adt_def(def_id);
2080 def.destructor(tcx); // force the destructor to be evaluated
2083 let attributes = tcx.get_attrs(def_id);
2084 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
2086 tcx.sess, attr.span, E0084,
2087 "unsupported representation for zero-variant enum")
2088 .span_label(sp, "zero-variant enum")
2093 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
2094 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
2095 if !tcx.features().repr128 {
2096 emit_feature_err(&tcx.sess.parse_sess,
2099 GateIssue::Language,
2100 "repr with 128-bit type is unstable");
2105 if let Some(ref e) = v.disr_expr {
2106 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
2110 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
2112 |var: &hir::Variant| match var.data {
2113 hir::VariantData::Unit(..) => true,
2117 let has_disr = |var: &hir::Variant| var.disr_expr.is_some();
2118 let has_non_units = vs.iter().any(|var| !is_unit(var));
2119 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
2120 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
2122 if disr_non_unit || (disr_units && has_non_units) {
2123 let mut err = struct_span_err!(tcx.sess, sp, E0732,
2124 "`#[repr(inttype)]` must be specified");
2129 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
2130 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
2131 // Check for duplicate discriminant values
2132 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
2133 let variant_did = def.variants[VariantIdx::new(i)].def_id;
2134 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
2135 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
2136 let i_span = match variant_i.disr_expr {
2137 Some(ref expr) => tcx.hir().span(expr.hir_id),
2138 None => tcx.hir().span(variant_i_hir_id)
2140 let span = match v.disr_expr {
2141 Some(ref expr) => tcx.hir().span(expr.hir_id),
2144 struct_span_err!(tcx.sess, span, E0081,
2145 "discriminant value `{}` already exists", disr_vals[i])
2146 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
2147 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
2150 disr_vals.push(discr);
2153 check_representable(tcx, sp, def_id);
2154 check_transparent(tcx, sp, def_id);
2157 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2158 span_err!(tcx.sess, span, E0533,
2159 "expected unit struct/variant or constant, found {} `{}`",
2161 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2164 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2165 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2169 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2170 -> &'tcx ty::GenericPredicates<'tcx>
2173 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2174 let item_id = tcx.hir().ty_param_owner(hir_id);
2175 let item_def_id = tcx.hir().local_def_id(item_id);
2176 let generics = tcx.generics_of(item_def_id);
2177 let index = generics.param_def_id_to_index[&def_id];
2178 tcx.arena.alloc(ty::GenericPredicates {
2180 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2182 ty::Predicate::Trait(ref data)
2183 if data.skip_binder().self_ty().is_param(index) => {
2184 // HACK(eddyb) should get the original `Span`.
2185 let span = tcx.def_span(def_id);
2186 Some((predicate, span))
2196 def: Option<&ty::GenericParamDef>,
2198 ) -> Option<ty::Region<'tcx>> {
2200 Some(def) => infer::EarlyBoundRegion(span, def.name),
2201 None => infer::MiscVariable(span)
2203 Some(self.next_region_var(v))
2206 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2207 if let Some(param) = param {
2208 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2213 self.next_ty_var(TypeVariableOrigin {
2214 kind: TypeVariableOriginKind::TypeInference,
2223 param: Option<&ty::GenericParamDef>,
2225 ) -> &'tcx Const<'tcx> {
2226 if let Some(param) = param {
2227 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2232 self.next_const_var(ty, ConstVariableOrigin {
2233 kind: ConstVariableOriginKind::ConstInference,
2239 fn projected_ty_from_poly_trait_ref(&self,
2242 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2245 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2247 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2251 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2254 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2255 if ty.has_escaping_bound_vars() {
2256 ty // FIXME: normalization and escaping regions
2258 self.normalize_associated_types_in(span, &ty)
2262 fn set_tainted_by_errors(&self) {
2263 self.infcx.set_tainted_by_errors()
2266 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2267 self.write_ty(hir_id, ty)
2271 /// Controls whether the arguments are tupled. This is used for the call
2274 /// Tupling means that all call-side arguments are packed into a tuple and
2275 /// passed as a single parameter. For example, if tupling is enabled, this
2278 /// fn f(x: (isize, isize))
2280 /// Can be called as:
2287 #[derive(Clone, Eq, PartialEq)]
2288 enum TupleArgumentsFlag {
2293 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2295 inh: &'a Inherited<'a, 'tcx>,
2296 param_env: ty::ParamEnv<'tcx>,
2297 body_id: hir::HirId,
2298 ) -> FnCtxt<'a, 'tcx> {
2302 err_count_on_creation: inh.tcx.sess.err_count(),
2304 ret_coercion_span: RefCell::new(None),
2306 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2307 hir::CRATE_HIR_ID)),
2308 diverges: Cell::new(Diverges::Maybe),
2309 has_errors: Cell::new(false),
2310 enclosing_breakables: RefCell::new(EnclosingBreakables {
2312 by_id: Default::default(),
2318 pub fn sess(&self) -> &Session {
2322 pub fn errors_reported_since_creation(&self) -> bool {
2323 self.tcx.sess.err_count() > self.err_count_on_creation
2326 /// Produces warning on the given node, if the current point in the
2327 /// function is unreachable, and there hasn't been another warning.
2328 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2329 // FIXME: Combine these two 'if' expressions into one once
2330 // let chains are implemented
2331 if let Diverges::Always { span: orig_span, custom_note } = self.diverges.get() {
2332 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2333 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2334 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2335 if !span.is_desugaring(DesugaringKind::CondTemporary) {
2336 self.diverges.set(Diverges::WarnedAlways);
2338 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2340 let msg = format!("unreachable {}", kind);
2341 self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg)
2344 custom_note.unwrap_or("any code following this expression is unreachable")
2353 code: ObligationCauseCode<'tcx>)
2354 -> ObligationCause<'tcx> {
2355 ObligationCause::new(span, self.body_id, code)
2358 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2359 self.cause(span, ObligationCauseCode::MiscObligation)
2362 /// Resolves type variables in `ty` if possible. Unlike the infcx
2363 /// version (resolve_vars_if_possible), this version will
2364 /// also select obligations if it seems useful, in an effort
2365 /// to get more type information.
2366 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2367 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2369 // No Infer()? Nothing needs doing.
2370 if !ty.has_infer_types() {
2371 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2375 // If `ty` is a type variable, see whether we already know what it is.
2376 ty = self.resolve_vars_if_possible(&ty);
2377 if !ty.has_infer_types() {
2378 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2382 // If not, try resolving pending obligations as much as
2383 // possible. This can help substantially when there are
2384 // indirect dependencies that don't seem worth tracking
2386 self.select_obligations_where_possible(false);
2387 ty = self.resolve_vars_if_possible(&ty);
2389 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2393 fn record_deferred_call_resolution(
2395 closure_def_id: DefId,
2396 r: DeferredCallResolution<'tcx>,
2398 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2399 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2402 fn remove_deferred_call_resolutions(
2404 closure_def_id: DefId,
2405 ) -> Vec<DeferredCallResolution<'tcx>> {
2406 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2407 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2410 pub fn tag(&self) -> String {
2411 format!("{:p}", self)
2414 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2415 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2416 span_bug!(span, "no type for local variable {}",
2417 self.tcx.hir().node_to_string(nid))
2422 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2423 debug!("write_ty({:?}, {:?}) in fcx {}",
2424 id, self.resolve_vars_if_possible(&ty), self.tag());
2425 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2427 if ty.references_error() {
2428 self.has_errors.set(true);
2429 self.set_tainted_by_errors();
2433 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2434 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2437 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2438 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2441 pub fn write_method_call(&self,
2443 method: MethodCallee<'tcx>) {
2444 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2445 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2446 self.write_substs(hir_id, method.substs);
2448 // When the method is confirmed, the `method.substs` includes
2449 // parameters from not just the method, but also the impl of
2450 // the method -- in particular, the `Self` type will be fully
2451 // resolved. However, those are not something that the "user
2452 // specified" -- i.e., those types come from the inferred type
2453 // of the receiver, not something the user wrote. So when we
2454 // create the user-substs, we want to replace those earlier
2455 // types with just the types that the user actually wrote --
2456 // that is, those that appear on the *method itself*.
2458 // As an example, if the user wrote something like
2459 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2460 // type of `foo` (possibly adjusted), but we don't want to
2461 // include that. We want just the `[_, u32]` part.
2462 if !method.substs.is_noop() {
2463 let method_generics = self.tcx.generics_of(method.def_id);
2464 if !method_generics.params.is_empty() {
2465 let user_type_annotation = self.infcx.probe(|_| {
2466 let user_substs = UserSubsts {
2467 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2468 let i = param.index as usize;
2469 if i < method_generics.parent_count {
2470 self.infcx.var_for_def(DUMMY_SP, param)
2475 user_self_ty: None, // not relevant here
2478 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2484 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2485 self.write_user_type_annotation(hir_id, user_type_annotation);
2490 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2491 if !substs.is_noop() {
2492 debug!("write_substs({:?}, {:?}) in fcx {}",
2497 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2501 /// Given the substs that we just converted from the HIR, try to
2502 /// canonicalize them and store them as user-given substitutions
2503 /// (i.e., substitutions that must be respected by the NLL check).
2505 /// This should be invoked **before any unifications have
2506 /// occurred**, so that annotations like `Vec<_>` are preserved
2508 pub fn write_user_type_annotation_from_substs(
2512 substs: SubstsRef<'tcx>,
2513 user_self_ty: Option<UserSelfTy<'tcx>>,
2516 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2517 user_self_ty={:?} in fcx {}",
2518 hir_id, def_id, substs, user_self_ty, self.tag(),
2521 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2522 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2523 &UserType::TypeOf(def_id, UserSubsts {
2528 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2529 self.write_user_type_annotation(hir_id, canonicalized);
2533 pub fn write_user_type_annotation(
2536 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2539 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2540 hir_id, canonical_user_type_annotation, self.tag(),
2543 if !canonical_user_type_annotation.is_identity() {
2544 self.tables.borrow_mut().user_provided_types_mut().insert(
2545 hir_id, canonical_user_type_annotation
2548 debug!("write_user_type_annotation: skipping identity substs");
2552 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2553 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2559 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2560 Entry::Vacant(entry) => { entry.insert(adj); },
2561 Entry::Occupied(mut entry) => {
2562 debug!(" - composing on top of {:?}", entry.get());
2563 match (&entry.get()[..], &adj[..]) {
2564 // Applying any adjustment on top of a NeverToAny
2565 // is a valid NeverToAny adjustment, because it can't
2567 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2569 Adjustment { kind: Adjust::Deref(_), .. },
2570 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2572 Adjustment { kind: Adjust::Deref(_), .. },
2573 .. // Any following adjustments are allowed.
2575 // A reborrow has no effect before a dereference.
2577 // FIXME: currently we never try to compose autoderefs
2578 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2580 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2581 expr, entry.get(), adj)
2583 *entry.get_mut() = adj;
2588 /// Basically whenever we are converting from a type scheme into
2589 /// the fn body space, we always want to normalize associated
2590 /// types as well. This function combines the two.
2591 fn instantiate_type_scheme<T>(&self,
2593 substs: SubstsRef<'tcx>,
2596 where T : TypeFoldable<'tcx>
2598 let value = value.subst(self.tcx, substs);
2599 let result = self.normalize_associated_types_in(span, &value);
2600 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2607 /// As `instantiate_type_scheme`, but for the bounds found in a
2608 /// generic type scheme.
2609 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2610 -> ty::InstantiatedPredicates<'tcx> {
2611 let bounds = self.tcx.predicates_of(def_id);
2612 let result = bounds.instantiate(self.tcx, substs);
2613 let result = self.normalize_associated_types_in(span, &result);
2614 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2621 /// Replaces the opaque types from the given value with type variables,
2622 /// and records the `OpaqueTypeMap` for later use during writeback. See
2623 /// `InferCtxt::instantiate_opaque_types` for more details.
2624 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2626 parent_id: hir::HirId,
2630 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2631 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2635 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2636 self.instantiate_opaque_types(
2645 let mut opaque_types = self.opaque_types.borrow_mut();
2646 for (ty, decl) in opaque_type_map {
2647 let old_value = opaque_types.insert(ty, decl);
2648 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2654 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2655 where T : TypeFoldable<'tcx>
2657 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2660 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2662 where T : TypeFoldable<'tcx>
2664 self.inh.partially_normalize_associated_types_in(span,
2670 pub fn require_type_meets(&self,
2673 code: traits::ObligationCauseCode<'tcx>,
2676 self.register_bound(
2679 traits::ObligationCause::new(span, self.body_id, code));
2682 pub fn require_type_is_sized(&self,
2685 code: traits::ObligationCauseCode<'tcx>)
2687 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem, None);
2688 self.require_type_meets(ty, span, code, lang_item);
2691 pub fn require_type_is_sized_deferred(&self,
2694 code: traits::ObligationCauseCode<'tcx>)
2696 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2699 pub fn register_bound(&self,
2702 cause: traits::ObligationCause<'tcx>)
2704 self.fulfillment_cx.borrow_mut()
2705 .register_bound(self, self.param_env, ty, def_id, cause);
2708 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2709 let t = AstConv::ast_ty_to_ty(self, ast_t);
2710 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2714 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2715 let ty = self.to_ty(ast_ty);
2716 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2718 if Self::can_contain_user_lifetime_bounds(ty) {
2719 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2720 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2721 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2727 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2728 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2729 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2732 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2733 AstConv::ast_const_to_const(self, ast_c, ty)
2736 // If the type given by the user has free regions, save it for later, since
2737 // NLL would like to enforce those. Also pass in types that involve
2738 // projections, since those can resolve to `'static` bounds (modulo #54940,
2739 // which hopefully will be fixed by the time you see this comment, dear
2740 // reader, although I have my doubts). Also pass in types with inference
2741 // types, because they may be repeated. Other sorts of things are already
2742 // sufficiently enforced with erased regions. =)
2743 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2745 T: TypeFoldable<'tcx>
2747 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2750 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2751 match self.tables.borrow().node_types().get(id) {
2753 None if self.is_tainted_by_errors() => self.tcx.types.err,
2755 bug!("no type for node {}: {} in fcx {}",
2756 id, self.tcx.hir().node_to_string(id),
2762 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2763 /// outlive the region `r`.
2764 pub fn register_wf_obligation(&self,
2767 code: traits::ObligationCauseCode<'tcx>)
2769 // WF obligations never themselves fail, so no real need to give a detailed cause:
2770 let cause = traits::ObligationCause::new(span, self.body_id, code);
2771 self.register_predicate(traits::Obligation::new(cause,
2773 ty::Predicate::WellFormed(ty)));
2776 /// Registers obligations that all types appearing in `substs` are well-formed.
2777 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2778 for ty in substs.types() {
2779 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2783 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2784 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2785 /// trait/region obligations.
2787 /// For example, if there is a function:
2790 /// fn foo<'a,T:'a>(...)
2793 /// and a reference:
2799 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2800 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2801 pub fn add_obligations_for_parameters(&self,
2802 cause: traits::ObligationCause<'tcx>,
2803 predicates: &ty::InstantiatedPredicates<'tcx>)
2805 assert!(!predicates.has_escaping_bound_vars());
2807 debug!("add_obligations_for_parameters(predicates={:?})",
2810 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2811 self.register_predicate(obligation);
2815 // FIXME(arielb1): use this instead of field.ty everywhere
2816 // Only for fields! Returns <none> for methods>
2817 // Indifferent to privacy flags
2818 pub fn field_ty(&self,
2820 field: &'tcx ty::FieldDef,
2821 substs: SubstsRef<'tcx>)
2824 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2827 fn check_casts(&self) {
2828 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2829 for cast in deferred_cast_checks.drain(..) {
2834 fn resolve_generator_interiors(&self, def_id: DefId) {
2835 let mut generators = self.deferred_generator_interiors.borrow_mut();
2836 for (body_id, interior, kind) in generators.drain(..) {
2837 self.select_obligations_where_possible(false);
2838 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2842 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2843 // Non-numerics get replaced with ! or () (depending on whether
2844 // feature(never_type) is enabled, unconstrained ints with i32,
2845 // unconstrained floats with f64.
2846 // Fallback becomes very dubious if we have encountered type-checking errors.
2847 // In that case, fallback to Error.
2848 // The return value indicates whether fallback has occurred.
2849 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2850 use rustc::ty::error::UnconstrainedNumeric::Neither;
2851 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2853 assert!(ty.is_ty_infer());
2854 let fallback = match self.type_is_unconstrained_numeric(ty) {
2855 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2856 UnconstrainedInt => self.tcx.types.i32,
2857 UnconstrainedFloat => self.tcx.types.f64,
2858 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2859 Neither => return false,
2861 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2862 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2866 fn select_all_obligations_or_error(&self) {
2867 debug!("select_all_obligations_or_error");
2868 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2869 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2873 /// Select as many obligations as we can at present.
2874 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2875 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2876 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2880 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2881 /// returns a type of `&T`, but the actual type we assign to the
2882 /// *expression* is `T`. So this function just peels off the return
2883 /// type by one layer to yield `T`.
2884 fn make_overloaded_place_return_type(&self,
2885 method: MethodCallee<'tcx>)
2886 -> ty::TypeAndMut<'tcx>
2888 // extract method return type, which will be &T;
2889 let ret_ty = method.sig.output();
2891 // method returns &T, but the type as visible to user is T, so deref
2892 ret_ty.builtin_deref(true).unwrap()
2898 base_expr: &'tcx hir::Expr,
2902 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2903 // FIXME(#18741) -- this is almost but not quite the same as the
2904 // autoderef that normal method probing does. They could likely be
2907 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2908 let mut result = None;
2909 while result.is_none() && autoderef.next().is_some() {
2910 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2912 autoderef.finalize(self);
2916 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2917 /// (and otherwise adjust) `base_expr`, looking for a type which either
2918 /// supports builtin indexing or overloaded indexing.
2919 /// This loop implements one step in that search; the autoderef loop
2920 /// is implemented by `lookup_indexing`.
2924 base_expr: &hir::Expr,
2925 autoderef: &Autoderef<'a, 'tcx>,
2928 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2929 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2930 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2937 for &unsize in &[false, true] {
2938 let mut self_ty = adjusted_ty;
2940 // We only unsize arrays here.
2941 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2942 self_ty = self.tcx.mk_slice(element_ty);
2948 // If some lookup succeeds, write callee into table and extract index/element
2949 // type from the method signature.
2950 // If some lookup succeeded, install method in table
2951 let input_ty = self.next_ty_var(TypeVariableOrigin {
2952 kind: TypeVariableOriginKind::AutoDeref,
2953 span: base_expr.span,
2955 let method = self.try_overloaded_place_op(
2956 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2958 let result = method.map(|ok| {
2959 debug!("try_index_step: success, using overloaded indexing");
2960 let method = self.register_infer_ok_obligations(ok);
2962 let mut adjustments = autoderef.adjust_steps(self, needs);
2963 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2964 let mutbl = match r_mutbl {
2965 hir::MutImmutable => AutoBorrowMutability::Immutable,
2966 hir::MutMutable => AutoBorrowMutability::Mutable {
2967 // Indexing can be desugared to a method call,
2968 // so maybe we could use two-phase here.
2969 // See the documentation of AllowTwoPhase for why that's
2970 // not the case today.
2971 allow_two_phase_borrow: AllowTwoPhase::No,
2974 adjustments.push(Adjustment {
2975 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2976 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2983 adjustments.push(Adjustment {
2984 kind: Adjust::Pointer(PointerCast::Unsize),
2985 target: method.sig.inputs()[0]
2988 self.apply_adjustments(base_expr, adjustments);
2990 self.write_method_call(expr.hir_id, method);
2991 (input_ty, self.make_overloaded_place_return_type(method).ty)
2993 if result.is_some() {
3001 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
3002 let (tr, name) = match (op, is_mut) {
3003 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
3004 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
3005 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
3006 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
3008 (tr, ast::Ident::with_dummy_span(name))
3011 fn try_overloaded_place_op(&self,
3014 arg_tys: &[Ty<'tcx>],
3017 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
3019 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
3025 // Try Mut first, if needed.
3026 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
3027 let method = match (needs, mut_tr) {
3028 (Needs::MutPlace, Some(trait_did)) => {
3029 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
3034 // Otherwise, fall back to the immutable version.
3035 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
3036 let method = match (method, imm_tr) {
3037 (None, Some(trait_did)) => {
3038 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
3040 (method, _) => method,
3046 fn check_method_argument_types(
3050 method: Result<MethodCallee<'tcx>, ()>,
3051 args_no_rcvr: &'tcx [hir::Expr],
3052 tuple_arguments: TupleArgumentsFlag,
3053 expected: Expectation<'tcx>,
3055 let has_error = match method {
3057 method.substs.references_error() || method.sig.references_error()
3062 let err_inputs = self.err_args(args_no_rcvr.len());
3064 let err_inputs = match tuple_arguments {
3065 DontTupleArguments => err_inputs,
3066 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
3069 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
3070 false, tuple_arguments, None);
3071 return self.tcx.types.err;
3074 let method = method.unwrap();
3075 // HACK(eddyb) ignore self in the definition (see above).
3076 let expected_arg_tys = self.expected_inputs_for_expected_output(
3079 method.sig.output(),
3080 &method.sig.inputs()[1..]
3082 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
3083 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
3084 self.tcx.hir().span_if_local(method.def_id));
3088 fn self_type_matches_expected_vid(
3090 trait_ref: ty::PolyTraitRef<'tcx>,
3091 expected_vid: ty::TyVid,
3093 let self_ty = self.shallow_resolve(trait_ref.self_ty());
3095 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
3096 trait_ref, self_ty, expected_vid
3099 ty::Infer(ty::TyVar(found_vid)) => {
3100 // FIXME: consider using `sub_root_var` here so we
3101 // can see through subtyping.
3102 let found_vid = self.root_var(found_vid);
3103 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
3104 expected_vid == found_vid
3110 fn obligations_for_self_ty<'b>(
3113 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
3116 // FIXME: consider using `sub_root_var` here so we
3117 // can see through subtyping.
3118 let ty_var_root = self.root_var(self_ty);
3119 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
3120 self_ty, ty_var_root,
3121 self.fulfillment_cx.borrow().pending_obligations());
3125 .pending_obligations()
3127 .filter_map(move |obligation| match obligation.predicate {
3128 ty::Predicate::Projection(ref data) =>
3129 Some((data.to_poly_trait_ref(self.tcx), obligation)),
3130 ty::Predicate::Trait(ref data) =>
3131 Some((data.to_poly_trait_ref(), obligation)),
3132 ty::Predicate::Subtype(..) => None,
3133 ty::Predicate::RegionOutlives(..) => None,
3134 ty::Predicate::TypeOutlives(..) => None,
3135 ty::Predicate::WellFormed(..) => None,
3136 ty::Predicate::ObjectSafe(..) => None,
3137 ty::Predicate::ConstEvaluatable(..) => None,
3138 // N.B., this predicate is created by breaking down a
3139 // `ClosureType: FnFoo()` predicate, where
3140 // `ClosureType` represents some `Closure`. It can't
3141 // possibly be referring to the current closure,
3142 // because we haven't produced the `Closure` for
3143 // this closure yet; this is exactly why the other
3144 // code is looking for a self type of a unresolved
3145 // inference variable.
3146 ty::Predicate::ClosureKind(..) => None,
3147 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
3150 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
3151 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
3152 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
3156 /// Generic function that factors out common logic from function calls,
3157 /// method calls and overloaded operators.
3158 fn check_argument_types(
3162 fn_inputs: &[Ty<'tcx>],
3163 expected_arg_tys: &[Ty<'tcx>],
3164 args: &'tcx [hir::Expr],
3166 tuple_arguments: TupleArgumentsFlag,
3167 def_span: Option<Span>,
3171 // Grab the argument types, supplying fresh type variables
3172 // if the wrong number of arguments were supplied
3173 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3179 // All the input types from the fn signature must outlive the call
3180 // so as to validate implied bounds.
3181 for &fn_input_ty in fn_inputs {
3182 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3185 let expected_arg_count = fn_inputs.len();
3187 let param_count_error = |expected_count: usize,
3192 let mut err = tcx.sess.struct_span_err_with_code(sp,
3193 &format!("this function takes {}{} but {} {} supplied",
3194 if c_variadic { "at least " } else { "" },
3195 potentially_plural_count(expected_count, "parameter"),
3196 potentially_plural_count(arg_count, "parameter"),
3197 if arg_count == 1 {"was"} else {"were"}),
3198 DiagnosticId::Error(error_code.to_owned()));
3200 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3201 err.span_label(def_s, "defined here");
3204 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3205 // remove closing `)` from the span
3206 let sugg_span = sugg_span.shrink_to_lo();
3207 err.span_suggestion(
3209 "expected the unit value `()`; create it with empty parentheses",
3211 Applicability::MachineApplicable);
3213 err.span_label(sp, format!("expected {}{}",
3214 if c_variadic { "at least " } else { "" },
3215 potentially_plural_count(expected_count, "parameter")));
3220 let mut expected_arg_tys = expected_arg_tys.to_vec();
3222 let formal_tys = if tuple_arguments == TupleArguments {
3223 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3224 match tuple_type.sty {
3225 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3226 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3227 expected_arg_tys = vec![];
3228 self.err_args(args.len())
3230 ty::Tuple(arg_types) => {
3231 expected_arg_tys = match expected_arg_tys.get(0) {
3232 Some(&ty) => match ty.sty {
3233 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3238 arg_types.iter().map(|k| k.expect_ty()).collect()
3241 span_err!(tcx.sess, sp, E0059,
3242 "cannot use call notation; the first type parameter \
3243 for the function trait is neither a tuple nor unit");
3244 expected_arg_tys = vec![];
3245 self.err_args(args.len())
3248 } else if expected_arg_count == supplied_arg_count {
3250 } else if c_variadic {
3251 if supplied_arg_count >= expected_arg_count {
3254 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3255 expected_arg_tys = vec![];
3256 self.err_args(supplied_arg_count)
3259 // is the missing argument of type `()`?
3260 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3261 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3262 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3263 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3267 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3269 expected_arg_tys = vec![];
3270 self.err_args(supplied_arg_count)
3273 debug!("check_argument_types: formal_tys={:?}",
3274 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3276 // If there is no expectation, expect formal_tys.
3277 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3283 // Check the arguments.
3284 // We do this in a pretty awful way: first we type-check any arguments
3285 // that are not closures, then we type-check the closures. This is so
3286 // that we have more information about the types of arguments when we
3287 // type-check the functions. This isn't really the right way to do this.
3288 for &check_closures in &[false, true] {
3289 debug!("check_closures={}", check_closures);
3291 // More awful hacks: before we check argument types, try to do
3292 // an "opportunistic" vtable resolution of any trait bounds on
3293 // the call. This helps coercions.
3295 self.select_obligations_where_possible(false);
3298 // For C-variadic functions, we don't have a declared type for all of
3299 // the arguments hence we only do our usual type checking with
3300 // the arguments who's types we do know.
3301 let t = if c_variadic {
3303 } else if tuple_arguments == TupleArguments {
3308 for (i, arg) in args.iter().take(t).enumerate() {
3309 // Warn only for the first loop (the "no closures" one).
3310 // Closure arguments themselves can't be diverging, but
3311 // a previous argument can, e.g., `foo(panic!(), || {})`.
3312 if !check_closures {
3313 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3316 let is_closure = match arg.node {
3317 ExprKind::Closure(..) => true,
3321 if is_closure != check_closures {
3325 debug!("checking the argument");
3326 let formal_ty = formal_tys[i];
3328 // The special-cased logic below has three functions:
3329 // 1. Provide as good of an expected type as possible.
3330 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3332 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3334 // 2. Coerce to the most detailed type that could be coerced
3335 // to, which is `expected_ty` if `rvalue_hint` returns an
3336 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3337 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3338 // We're processing function arguments so we definitely want to use
3339 // two-phase borrows.
3340 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3342 // 3. Relate the expected type and the formal one,
3343 // if the expected type was used for the coercion.
3344 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3348 // We also need to make sure we at least write the ty of the other
3349 // arguments which we skipped above.
3351 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3352 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3353 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3356 for arg in args.iter().skip(expected_arg_count) {
3357 let arg_ty = self.check_expr(&arg);
3359 // There are a few types which get autopromoted when passed via varargs
3360 // in C but we just error out instead and require explicit casts.
3361 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3363 ty::Float(ast::FloatTy::F32) => {
3364 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3366 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3367 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3369 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3370 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3373 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3374 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3375 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3383 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3384 vec![self.tcx.types.err; len]
3387 // AST fragment checking
3390 expected: Expectation<'tcx>)
3396 ast::LitKind::Str(..) => tcx.mk_static_str(),
3397 ast::LitKind::ByteStr(ref v) => {
3398 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3399 tcx.mk_array(tcx.types.u8, v.len() as u64))
3401 ast::LitKind::Byte(_) => tcx.types.u8,
3402 ast::LitKind::Char(_) => tcx.types.char,
3403 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3404 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3405 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3406 let opt_ty = expected.to_option(self).and_then(|ty| {
3408 ty::Int(_) | ty::Uint(_) => Some(ty),
3409 ty::Char => Some(tcx.types.u8),
3410 ty::RawPtr(..) => Some(tcx.types.usize),
3411 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3415 opt_ty.unwrap_or_else(|| self.next_int_var())
3417 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3418 ast::LitKind::FloatUnsuffixed(_) => {
3419 let opt_ty = expected.to_option(self).and_then(|ty| {
3421 ty::Float(_) => Some(ty),
3425 opt_ty.unwrap_or_else(|| self.next_float_var())
3427 ast::LitKind::Bool(_) => tcx.types.bool,
3428 ast::LitKind::Err(_) => tcx.types.err,
3432 // Determine the `Self` type, using fresh variables for all variables
3433 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3434 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3436 pub fn impl_self_ty(&self,
3437 span: Span, // (potential) receiver for this impl
3439 -> TypeAndSubsts<'tcx> {
3440 let ity = self.tcx.type_of(did);
3441 debug!("impl_self_ty: ity={:?}", ity);
3443 let substs = self.fresh_substs_for_item(span, did);
3444 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3446 TypeAndSubsts { substs: substs, ty: substd_ty }
3449 /// Unifies the output type with the expected type early, for more coercions
3450 /// and forward type information on the input expressions.
3451 fn expected_inputs_for_expected_output(&self,
3453 expected_ret: Expectation<'tcx>,
3454 formal_ret: Ty<'tcx>,
3455 formal_args: &[Ty<'tcx>])
3457 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3458 let ret_ty = match expected_ret.only_has_type(self) {
3460 None => return Vec::new()
3462 let expect_args = self.fudge_inference_if_ok(|| {
3463 // Attempt to apply a subtyping relationship between the formal
3464 // return type (likely containing type variables if the function
3465 // is polymorphic) and the expected return type.
3466 // No argument expectations are produced if unification fails.
3467 let origin = self.misc(call_span);
3468 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3470 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3471 // to identity so the resulting type is not constrained.
3474 // Process any obligations locally as much as
3475 // we can. We don't care if some things turn
3476 // out unconstrained or ambiguous, as we're
3477 // just trying to get hints here.
3478 self.save_and_restore_in_snapshot_flag(|_| {
3479 let mut fulfill = TraitEngine::new(self.tcx);
3480 for obligation in ok.obligations {
3481 fulfill.register_predicate_obligation(self, obligation);
3483 fulfill.select_where_possible(self)
3484 }).map_err(|_| ())?;
3486 Err(_) => return Err(()),
3489 // Record all the argument types, with the substitutions
3490 // produced from the above subtyping unification.
3491 Ok(formal_args.iter().map(|ty| {
3492 self.resolve_vars_if_possible(ty)
3494 }).unwrap_or_default();
3495 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3496 formal_args, formal_ret,
3497 expect_args, expected_ret);
3501 pub fn check_struct_path(&self,
3504 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3505 let path_span = match *qpath {
3506 QPath::Resolved(_, ref path) => path.span,
3507 QPath::TypeRelative(ref qself, _) => qself.span
3509 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3510 let variant = match def {
3512 self.set_tainted_by_errors();
3515 Res::Def(DefKind::Variant, _) => {
3517 ty::Adt(adt, substs) => {
3518 Some((adt.variant_of_res(def), adt.did, substs))
3520 _ => bug!("unexpected type: {:?}", ty)
3523 Res::Def(DefKind::Struct, _)
3524 | Res::Def(DefKind::Union, _)
3525 | Res::Def(DefKind::TyAlias, _)
3526 | Res::Def(DefKind::AssocTy, _)
3527 | Res::SelfTy(..) => {
3529 ty::Adt(adt, substs) if !adt.is_enum() => {
3530 Some((adt.non_enum_variant(), adt.did, substs))
3535 _ => bug!("unexpected definition: {:?}", def)
3538 if let Some((variant, did, substs)) = variant {
3539 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3540 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3542 // Check bounds on type arguments used in the path.
3543 let bounds = self.instantiate_bounds(path_span, did, substs);
3544 let cause = traits::ObligationCause::new(path_span, self.body_id,
3545 traits::ItemObligation(did));
3546 self.add_obligations_for_parameters(cause, &bounds);
3550 struct_span_err!(self.tcx.sess, path_span, E0071,
3551 "expected struct, variant or union type, found {}",
3552 ty.sort_string(self.tcx))
3553 .span_label(path_span, "not a struct")
3559 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3560 // The newly resolved definition is written into `type_dependent_defs`.
3561 fn finish_resolving_struct_path(&self,
3568 QPath::Resolved(ref maybe_qself, ref path) => {
3569 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3570 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3573 QPath::TypeRelative(ref qself, ref segment) => {
3574 let ty = self.to_ty(qself);
3576 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3581 let result = AstConv::associated_path_to_ty(
3590 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3591 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3593 // Write back the new resolution.
3594 self.write_resolution(hir_id, result);
3596 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3601 /// Resolves an associated value path into a base type and associated constant, or method
3602 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3603 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3607 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3609 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3610 let (ty, qself, item_segment) = match *qpath {
3611 QPath::Resolved(ref opt_qself, ref path) => {
3613 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3614 &path.segments[..]);
3616 QPath::TypeRelative(ref qself, ref segment) => {
3617 (self.to_ty(qself), qself, segment)
3620 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3621 // Return directly on cache hit. This is useful to avoid doubly reporting
3622 // errors with default match binding modes. See #44614.
3623 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3624 .unwrap_or(Res::Err);
3625 return (def, Some(ty), slice::from_ref(&**item_segment));
3627 let item_name = item_segment.ident;
3628 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3629 let result = match error {
3630 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3631 _ => Err(ErrorReported),
3633 if item_name.name != kw::Invalid {
3634 self.report_method_error(
3638 SelfSource::QPath(qself),
3641 ).map(|mut e| e.emit());
3646 // Write back the new resolution.
3647 self.write_resolution(hir_id, result);
3649 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3651 slice::from_ref(&**item_segment),
3655 pub fn check_decl_initializer(
3657 local: &'tcx hir::Local,
3658 init: &'tcx hir::Expr,
3660 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3661 // for #42640 (default match binding modes).
3664 let ref_bindings = local.pat.contains_explicit_ref_binding();
3666 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3667 if let Some(m) = ref_bindings {
3668 // Somewhat subtle: if we have a `ref` binding in the pattern,
3669 // we want to avoid introducing coercions for the RHS. This is
3670 // both because it helps preserve sanity and, in the case of
3671 // ref mut, for soundness (issue #23116). In particular, in
3672 // the latter case, we need to be clear that the type of the
3673 // referent for the reference that results is *equal to* the
3674 // type of the place it is referencing, and not some
3675 // supertype thereof.
3676 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3677 self.demand_eqtype(init.span, local_ty, init_ty);
3680 self.check_expr_coercable_to_type(init, local_ty)
3684 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3685 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3686 self.write_ty(local.hir_id, t);
3688 if let Some(ref init) = local.init {
3689 let init_ty = self.check_decl_initializer(local, &init);
3690 if init_ty.references_error() {
3691 self.write_ty(local.hir_id, init_ty);
3695 self.check_pat_top(&local.pat, t, None);
3696 let pat_ty = self.node_ty(local.pat.hir_id);
3697 if pat_ty.references_error() {
3698 self.write_ty(local.hir_id, pat_ty);
3702 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3703 // Don't do all the complex logic below for `DeclItem`.
3705 hir::StmtKind::Item(..) => return,
3706 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3709 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3711 // Hide the outer diverging and `has_errors` flags.
3712 let old_diverges = self.diverges.get();
3713 let old_has_errors = self.has_errors.get();
3714 self.diverges.set(Diverges::Maybe);
3715 self.has_errors.set(false);
3718 hir::StmtKind::Local(ref l) => {
3719 self.check_decl_local(&l);
3722 hir::StmtKind::Item(_) => {}
3723 hir::StmtKind::Expr(ref expr) => {
3724 // Check with expected type of `()`.
3725 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3727 hir::StmtKind::Semi(ref expr) => {
3728 self.check_expr(&expr);
3732 // Combine the diverging and `has_error` flags.
3733 self.diverges.set(self.diverges.get() | old_diverges);
3734 self.has_errors.set(self.has_errors.get() | old_has_errors);
3737 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3738 let unit = self.tcx.mk_unit();
3739 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3741 // if the block produces a `!` value, that can always be
3742 // (effectively) coerced to unit.
3744 self.demand_suptype(blk.span, unit, ty);
3748 /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
3749 /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
3750 /// when given code like the following:
3752 /// if false { return 0i32; } else { 1u32 }
3753 /// // ^^^^ point at this instead of the whole `if` expression
3755 fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
3756 if let hir::ExprKind::Match(_, arms, _) = &expr.node {
3757 let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
3758 self.in_progress_tables
3759 .and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
3760 .and_then(|arm_ty| {
3761 if arm_ty.is_never() {
3764 Some(match &arm.body.node {
3765 // Point at the tail expression when possible.
3766 hir::ExprKind::Block(block, _) => block.expr
3769 .unwrap_or(block.span),
3775 if arm_spans.len() == 1 {
3776 return arm_spans[0];
3782 fn check_block_with_expected(
3784 blk: &'tcx hir::Block,
3785 expected: Expectation<'tcx>,
3788 let mut fcx_ps = self.ps.borrow_mut();
3789 let unsafety_state = fcx_ps.recurse(blk);
3790 replace(&mut *fcx_ps, unsafety_state)
3793 // In some cases, blocks have just one exit, but other blocks
3794 // can be targeted by multiple breaks. This can happen both
3795 // with labeled blocks as well as when we desugar
3796 // a `try { ... }` expression.
3800 // 'a: { if true { break 'a Err(()); } Ok(()) }
3802 // Here we would wind up with two coercions, one from
3803 // `Err(())` and the other from the tail expression
3804 // `Ok(())`. If the tail expression is omitted, that's a
3805 // "forced unit" -- unless the block diverges, in which
3806 // case we can ignore the tail expression (e.g., `'a: {
3807 // break 'a 22; }` would not force the type of the block
3809 let tail_expr = blk.expr.as_ref();
3810 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3811 let coerce = if blk.targeted_by_break {
3812 CoerceMany::new(coerce_to_ty)
3814 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3815 Some(e) => slice::from_ref(e),
3818 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3821 let prev_diverges = self.diverges.get();
3822 let ctxt = BreakableCtxt {
3823 coerce: Some(coerce),
3827 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3828 for s in &blk.stmts {
3832 // check the tail expression **without** holding the
3833 // `enclosing_breakables` lock below.
3834 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3836 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3837 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3838 let coerce = ctxt.coerce.as_mut().unwrap();
3839 if let Some(tail_expr_ty) = tail_expr_ty {
3840 let tail_expr = tail_expr.unwrap();
3841 let span = self.get_expr_coercion_span(tail_expr);
3842 let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
3843 coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
3845 // Subtle: if there is no explicit tail expression,
3846 // that is typically equivalent to a tail expression
3847 // of `()` -- except if the block diverges. In that
3848 // case, there is no value supplied from the tail
3849 // expression (assuming there are no other breaks,
3850 // this implies that the type of the block will be
3853 // #41425 -- label the implicit `()` as being the
3854 // "found type" here, rather than the "expected type".
3855 if !self.diverges.get().always() {
3856 // #50009 -- Do not point at the entire fn block span, point at the return type
3857 // span, as it is the cause of the requirement, and
3858 // `consider_hint_about_removing_semicolon` will point at the last expression
3859 // if it were a relevant part of the error. This improves usability in editors
3860 // that highlight errors inline.
3861 let mut sp = blk.span;
3862 let mut fn_span = None;
3863 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3864 let ret_sp = decl.output.span();
3865 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3866 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3867 // output would otherwise be incorrect and even misleading. Make sure
3868 // the span we're aiming at correspond to a `fn` body.
3869 if block_sp == blk.span {
3871 fn_span = Some(ident.span);
3875 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3876 if let Some(expected_ty) = expected.only_has_type(self) {
3877 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3879 if let Some(fn_span) = fn_span {
3882 "implicitly returns `()` as its body has no tail or `return` \
3892 // If we can break from the block, then the block's exit is always reachable
3893 // (... as long as the entry is reachable) - regardless of the tail of the block.
3894 self.diverges.set(prev_diverges);
3897 let mut ty = ctxt.coerce.unwrap().complete(self);
3899 if self.has_errors.get() || ty.references_error() {
3900 ty = self.tcx.types.err
3903 self.write_ty(blk.hir_id, ty);
3905 *self.ps.borrow_mut() = prev;
3909 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3910 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3912 Node::Item(&hir::Item {
3913 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3915 Node::ImplItem(&hir::ImplItem {
3916 node: hir::ImplItemKind::Method(_, body_id), ..
3918 let body = self.tcx.hir().body(body_id);
3919 if let ExprKind::Block(block, _) = &body.value.node {
3920 return Some(block.span);
3928 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3929 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3930 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3931 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3934 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3935 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3937 Node::Item(&hir::Item {
3938 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3940 // This is less than ideal, it will not suggest a return type span on any
3941 // method called `main`, regardless of whether it is actually the entry point,
3942 // but it will still present it as the reason for the expected type.
3943 Some((decl, ident, ident.name != sym::main))
3945 Node::TraitItem(&hir::TraitItem {
3946 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3949 }) => Some((decl, ident, true)),
3950 Node::ImplItem(&hir::ImplItem {
3951 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3954 }) => Some((decl, ident, false)),
3959 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3960 /// suggestion can be made, `None` otherwise.
3961 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3962 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3963 // `while` before reaching it, as block tail returns are not available in them.
3964 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3965 let parent = self.tcx.hir().get(blk_id);
3966 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3970 /// On implicit return expressions with mismatched types, provides the following suggestions:
3972 /// - Points out the method's return type as the reason for the expected type.
3973 /// - Possible missing semicolon.
3974 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3975 pub fn suggest_mismatched_types_on_tail(
3977 err: &mut DiagnosticBuilder<'tcx>,
3978 expression: &'tcx hir::Expr,
3984 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3985 let mut pointing_at_return_type = false;
3986 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3987 pointing_at_return_type = self.suggest_missing_return_type(
3988 err, &fn_decl, expected, found, can_suggest);
3990 self.suggest_ref_or_into(err, expression, expected, found);
3991 self.suggest_boxing_when_appropriate(err, expression, expected, found);
3992 pointing_at_return_type
3995 /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
3996 /// the ctor would successfully solve the type mismatch and if so, suggest it:
3998 /// fn foo(x: usize) -> usize { x }
3999 /// let x: usize = foo; // suggest calling the `foo` function: `foo(42)`
4003 err: &mut DiagnosticBuilder<'tcx>,
4008 let hir = self.tcx.hir();
4009 let (def_id, sig) = match found.sty {
4010 ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
4011 ty::Closure(def_id, substs) => {
4012 // We don't use `closure_sig` to account for malformed closures like
4013 // `|_: [_; continue]| {}` and instead we don't suggest anything.
4014 let closure_sig_ty = substs.closure_sig_ty(def_id, self.tcx);
4015 (def_id, match closure_sig_ty.sty {
4016 ty::FnPtr(sig) => sig,
4024 .replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, &sig)
4026 let sig = self.normalize_associated_types_in(expr.span, &sig);
4027 if self.can_coerce(sig.output(), expected) {
4028 let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
4029 (String::new(), Applicability::MachineApplicable)
4031 ("...".to_string(), Applicability::HasPlaceholders)
4033 let mut msg = "call this function";
4034 match hir.get_if_local(def_id) {
4035 Some(Node::Item(hir::Item {
4036 node: ItemKind::Fn(.., body_id),
4039 Some(Node::ImplItem(hir::ImplItem {
4040 node: hir::ImplItemKind::Method(_, body_id),
4043 Some(Node::TraitItem(hir::TraitItem {
4044 node: hir::TraitItemKind::Method(.., hir::TraitMethod::Provided(body_id)),
4047 let body = hir.body(*body_id);
4048 sugg_call = body.params.iter()
4049 .map(|param| match ¶m.pat.node {
4050 hir::PatKind::Binding(_, _, ident, None)
4051 if ident.name != kw::SelfLower => ident.to_string(),
4052 _ => "_".to_string(),
4053 }).collect::<Vec<_>>().join(", ");
4055 Some(Node::Expr(hir::Expr {
4056 node: ExprKind::Closure(_, _, body_id, closure_span, _),
4057 span: full_closure_span,
4060 if *full_closure_span == expr.span {
4063 err.span_label(*closure_span, "closure defined here");
4064 msg = "call this closure";
4065 let body = hir.body(*body_id);
4066 sugg_call = body.params.iter()
4067 .map(|param| match ¶m.pat.node {
4068 hir::PatKind::Binding(_, _, ident, None)
4069 if ident.name != kw::SelfLower => ident.to_string(),
4070 _ => "_".to_string(),
4071 }).collect::<Vec<_>>().join(", ");
4073 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
4074 sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
4075 match hir.as_local_hir_id(def_id).and_then(|hir_id| hir.def_kind(hir_id)) {
4076 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
4077 msg = "instantiate this tuple variant";
4079 Some(hir::def::DefKind::Ctor(hir::def::CtorOf::Struct, _)) => {
4080 msg = "instantiate this tuple struct";
4085 Some(Node::ForeignItem(hir::ForeignItem {
4086 node: hir::ForeignItemKind::Fn(_, idents, _),
4089 Some(Node::TraitItem(hir::TraitItem {
4090 node: hir::TraitItemKind::Method(.., hir::TraitMethod::Required(idents)),
4092 })) => sugg_call = idents.iter()
4093 .map(|ident| if ident.name != kw::SelfLower {
4097 }).collect::<Vec<_>>()
4101 if let Ok(code) = self.sess().source_map().span_to_snippet(expr.span) {
4102 err.span_suggestion(
4104 &format!("use parentheses to {}", msg),
4105 format!("{}({})", code, sugg_call),
4114 pub fn suggest_ref_or_into(
4116 err: &mut DiagnosticBuilder<'tcx>,
4121 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
4122 err.span_suggestion(
4126 Applicability::MachineApplicable,
4128 } else if let (ty::FnDef(def_id, ..), true) = (
4130 self.suggest_fn_call(err, expr, expected, found),
4132 if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
4133 let sp = self.sess().source_map().def_span(sp);
4134 err.span_label(sp, &format!("{} defined here", found));
4136 } else if !self.check_for_cast(err, expr, found, expected) {
4137 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
4141 let methods = self.get_conversion_methods(expr.span, expected, found);
4142 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
4143 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
4144 .filter_map(|(receiver, method)| {
4145 let method_call = format!(".{}()", method.ident);
4146 if receiver.ends_with(&method_call) {
4147 None // do not suggest code that is already there (#53348)
4149 let method_call_list = [".to_vec()", ".to_string()"];
4150 let sugg = if receiver.ends_with(".clone()")
4151 && method_call_list.contains(&method_call.as_str()) {
4152 let max_len = receiver.rfind(".").unwrap();
4153 format!("{}{}", &receiver[..max_len], method_call)
4155 format!("{}{}", receiver, method_call)
4157 Some(if is_struct_pat_shorthand_field {
4158 format!("{}: {}", receiver, sugg)
4164 if suggestions.peek().is_some() {
4165 err.span_suggestions(
4167 "try using a conversion method",
4169 Applicability::MaybeIncorrect,
4176 /// When encountering the expected boxed value allocated in the stack, suggest allocating it
4177 /// in the heap by calling `Box::new()`.
4178 fn suggest_boxing_when_appropriate(
4180 err: &mut DiagnosticBuilder<'tcx>,
4185 if self.tcx.hir().is_const_context(expr.hir_id) {
4186 // Do not suggest `Box::new` in const context.
4189 if !expected.is_box() || found.is_box() {
4192 let boxed_found = self.tcx.mk_box(found);
4193 if let (true, Ok(snippet)) = (
4194 self.can_coerce(boxed_found, expected),
4195 self.sess().source_map().span_to_snippet(expr.span),
4197 err.span_suggestion(
4199 "store this in the heap by calling `Box::new`",
4200 format!("Box::new({})", snippet),
4201 Applicability::MachineApplicable,
4203 err.note("for more on the distinction between the stack and the \
4204 heap, read https://doc.rust-lang.org/book/ch15-01-box.html, \
4205 https://doc.rust-lang.org/rust-by-example/std/box.html, and \
4206 https://doc.rust-lang.org/std/boxed/index.html");
4211 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
4215 /// bar_that_returns_u32()
4219 /// This routine checks if the return expression in a block would make sense on its own as a
4220 /// statement and the return type has been left as default or has been specified as `()`. If so,
4221 /// it suggests adding a semicolon.
4222 fn suggest_missing_semicolon(
4224 err: &mut DiagnosticBuilder<'tcx>,
4225 expression: &'tcx hir::Expr,
4229 if expected.is_unit() {
4230 // `BlockTailExpression` only relevant if the tail expr would be
4231 // useful on its own.
4232 match expression.node {
4233 ExprKind::Call(..) |
4234 ExprKind::MethodCall(..) |
4235 ExprKind::Loop(..) |
4236 ExprKind::Match(..) |
4237 ExprKind::Block(..) => {
4238 let sp = self.tcx.sess.source_map().next_point(cause_span);
4239 err.span_suggestion(
4241 "try adding a semicolon",
4243 Applicability::MachineApplicable);
4250 /// A possible error is to forget to add a return type that is needed:
4254 /// bar_that_returns_u32()
4258 /// This routine checks if the return type is left as default, the method is not part of an
4259 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
4261 fn suggest_missing_return_type(
4263 err: &mut DiagnosticBuilder<'tcx>,
4264 fn_decl: &hir::FnDecl,
4269 // Only suggest changing the return type for methods that
4270 // haven't set a return type at all (and aren't `fn main()` or an impl).
4271 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
4272 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
4273 err.span_suggestion(
4275 "try adding a return type",
4276 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
4277 Applicability::MachineApplicable);
4280 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
4281 err.span_label(span, "possibly return type missing here?");
4284 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
4285 // `fn main()` must return `()`, do not suggest changing return type
4286 err.span_label(span, "expected `()` because of default return type");
4289 // expectation was caused by something else, not the default return
4290 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
4291 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
4292 // Only point to return type if the expected type is the return type, as if they
4293 // are not, the expectation must have been caused by something else.
4294 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
4296 let ty = AstConv::ast_ty_to_ty(self, ty);
4297 debug!("suggest_missing_return_type: return type {:?}", ty);
4298 debug!("suggest_missing_return_type: expected type {:?}", ty);
4299 if ty.sty == expected.sty {
4300 err.span_label(sp, format!("expected `{}` because of return type",
4309 /// A possible error is to forget to add `.await` when using futures:
4312 /// async fn make_u32() -> u32 {
4316 /// fn take_u32(x: u32) {}
4318 /// async fn foo() {
4319 /// let x = make_u32();
4324 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
4325 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
4326 /// `.await` to the tail of the expression.
4327 fn suggest_missing_await(
4329 err: &mut DiagnosticBuilder<'tcx>,
4334 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
4335 // body isn't `async`.
4336 let item_id = self.tcx().hir().get_parent_node(self.body_id);
4337 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
4338 let body = self.tcx().hir().body(body_id);
4339 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
4341 // Check for `Future` implementations by constructing a predicate to
4342 // prove: `<T as Future>::Output == U`
4343 let future_trait = self.tcx.lang_items().future_trait().unwrap();
4344 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
4345 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
4346 // `<T as Future>::Output`
4347 projection_ty: ty::ProjectionTy {
4349 substs: self.tcx.mk_substs_trait(
4351 self.fresh_substs_for_item(sp, item_def_id)
4358 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4359 if self.infcx.predicate_may_hold(&obligation) {
4360 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4361 err.span_suggestion(
4363 "consider using `.await` here",
4364 format!("{}.await", code),
4365 Applicability::MaybeIncorrect,
4373 /// A common error is to add an extra semicolon:
4376 /// fn foo() -> usize {
4381 /// This routine checks if the final statement in a block is an
4382 /// expression with an explicit semicolon whose type is compatible
4383 /// with `expected_ty`. If so, it suggests removing the semicolon.
4384 fn consider_hint_about_removing_semicolon(
4386 blk: &'tcx hir::Block,
4387 expected_ty: Ty<'tcx>,
4388 err: &mut DiagnosticBuilder<'_>,
4390 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4391 err.span_suggestion(
4393 "consider removing this semicolon",
4395 Applicability::MachineApplicable,
4400 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4401 // Be helpful when the user wrote `{... expr;}` and
4402 // taking the `;` off is enough to fix the error.
4403 let last_stmt = blk.stmts.last()?;
4404 let last_expr = match last_stmt.node {
4405 hir::StmtKind::Semi(ref e) => e,
4408 let last_expr_ty = self.node_ty(last_expr.hir_id);
4409 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4412 let original_span = original_sp(last_stmt.span, blk.span);
4413 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4416 // Instantiates the given path, which must refer to an item with the given
4417 // number of type parameters and type.
4418 pub fn instantiate_value_path(&self,
4419 segments: &[hir::PathSegment],
4420 self_ty: Option<Ty<'tcx>>,
4424 -> (Ty<'tcx>, Res) {
4426 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4435 let path_segs = match res {
4436 Res::Local(_) | Res::SelfCtor(_) => vec![],
4437 Res::Def(kind, def_id) =>
4438 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4439 _ => bug!("instantiate_value_path on {:?}", res),
4442 let mut user_self_ty = None;
4443 let mut is_alias_variant_ctor = false;
4445 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4446 if let Some(self_ty) = self_ty {
4447 let adt_def = self_ty.ty_adt_def().unwrap();
4448 user_self_ty = Some(UserSelfTy {
4449 impl_def_id: adt_def.did,
4452 is_alias_variant_ctor = true;
4455 Res::Def(DefKind::Method, def_id)
4456 | Res::Def(DefKind::AssocConst, def_id) => {
4457 let container = tcx.associated_item(def_id).container;
4458 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4460 ty::TraitContainer(trait_did) => {
4461 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4463 ty::ImplContainer(impl_def_id) => {
4464 if segments.len() == 1 {
4465 // `<T>::assoc` will end up here, and so
4466 // can `T::assoc`. It this came from an
4467 // inherent impl, we need to record the
4468 // `T` for posterity (see `UserSelfTy` for
4470 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4471 user_self_ty = Some(UserSelfTy {
4482 // Now that we have categorized what space the parameters for each
4483 // segment belong to, let's sort out the parameters that the user
4484 // provided (if any) into their appropriate spaces. We'll also report
4485 // errors if type parameters are provided in an inappropriate place.
4487 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4488 let generics_has_err = AstConv::prohibit_generics(
4489 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4490 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4497 if let Res::Local(hid) = res {
4498 let ty = self.local_ty(span, hid).decl_ty;
4499 let ty = self.normalize_associated_types_in(span, &ty);
4500 self.write_ty(hir_id, ty);
4504 if generics_has_err {
4505 // Don't try to infer type parameters when prohibited generic arguments were given.
4506 user_self_ty = None;
4509 // Now we have to compare the types that the user *actually*
4510 // provided against the types that were *expected*. If the user
4511 // did not provide any types, then we want to substitute inference
4512 // variables. If the user provided some types, we may still need
4513 // to add defaults. If the user provided *too many* types, that's
4516 let mut infer_args_for_err = FxHashSet::default();
4517 for &PathSeg(def_id, index) in &path_segs {
4518 let seg = &segments[index];
4519 let generics = tcx.generics_of(def_id);
4520 // Argument-position `impl Trait` is treated as a normal generic
4521 // parameter internally, but we don't allow users to specify the
4522 // parameter's value explicitly, so we have to do some error-
4524 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4529 false, // `is_method_call`
4531 if suppress_errors {
4532 infer_args_for_err.insert(index);
4533 self.set_tainted_by_errors(); // See issue #53251.
4537 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4538 tcx.generics_of(*def_id).has_self
4539 }).unwrap_or(false);
4541 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4542 let ty = self.impl_self_ty(span, impl_def_id).ty;
4543 let adt_def = ty.ty_adt_def();
4546 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4547 let variant = adt_def.non_enum_variant();
4548 let ctor_def_id = variant.ctor_def_id.unwrap();
4550 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4555 let mut err = tcx.sess.struct_span_err(span,
4556 "the `Self` constructor can only be used with tuple or unit structs");
4557 if let Some(adt_def) = adt_def {
4558 match adt_def.adt_kind() {
4560 err.help("did you mean to use one of the enum's variants?");
4564 err.span_suggestion(
4566 "use curly brackets",
4567 String::from("Self { /* fields */ }"),
4568 Applicability::HasPlaceholders,
4575 return (tcx.types.err, res)
4581 let def_id = res.def_id();
4583 // The things we are substituting into the type should not contain
4584 // escaping late-bound regions, and nor should the base type scheme.
4585 let ty = tcx.type_of(def_id);
4587 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4593 // Provide the generic args, and whether types should be inferred.
4595 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4598 // If we've encountered an `impl Trait`-related error, we're just
4599 // going to infer the arguments for better error messages.
4600 if !infer_args_for_err.contains(&index) {
4601 // Check whether the user has provided generic arguments.
4602 if let Some(ref data) = segments[index].args {
4603 return (Some(data), segments[index].infer_args);
4606 return (None, segments[index].infer_args);
4611 // Provide substitutions for parameters for which (valid) arguments have been provided.
4613 match (¶m.kind, arg) {
4614 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4615 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4617 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4618 self.to_ty(ty).into()
4620 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4621 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4623 _ => unreachable!(),
4626 // Provide substitutions for parameters for which arguments are inferred.
4627 |substs, param, infer_args| {
4629 GenericParamDefKind::Lifetime => {
4630 self.re_infer(Some(param), span).unwrap().into()
4632 GenericParamDefKind::Type { has_default, .. } => {
4633 if !infer_args && has_default {
4634 // If we have a default, then we it doesn't matter that we're not
4635 // inferring the type arguments: we provide the default where any
4637 let default = tcx.type_of(param.def_id);
4640 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4643 // If no type arguments were provided, we have to infer them.
4644 // This case also occurs as a result of some malformed input, e.g.
4645 // a lifetime argument being given instead of a type parameter.
4646 // Using inference instead of `Error` gives better error messages.
4647 self.var_for_def(span, param)
4650 GenericParamDefKind::Const => {
4651 // FIXME(const_generics:defaults)
4652 // No const parameters were provided, we have to infer them.
4653 self.var_for_def(span, param)
4658 assert!(!substs.has_escaping_bound_vars());
4659 assert!(!ty.has_escaping_bound_vars());
4661 // First, store the "user substs" for later.
4662 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4664 // Add all the obligations that are required, substituting and
4665 // normalized appropriately.
4666 let bounds = self.instantiate_bounds(span, def_id, &substs);
4667 self.add_obligations_for_parameters(
4668 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4671 // Substitute the values for the type parameters into the type of
4672 // the referenced item.
4673 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4675 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4676 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4677 // is inherent, there is no `Self` parameter; instead, the impl needs
4678 // type parameters, which we can infer by unifying the provided `Self`
4679 // with the substituted impl type.
4680 // This also occurs for an enum variant on a type alias.
4681 let ty = tcx.type_of(impl_def_id);
4683 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4684 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4685 Ok(ok) => self.register_infer_ok_obligations(ok),
4687 self.tcx.sess.delay_span_bug(span, &format!(
4688 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4696 self.check_rustc_args_require_const(def_id, hir_id, span);
4698 debug!("instantiate_value_path: type of {:?} is {:?}",
4701 self.write_substs(hir_id, substs);
4703 (ty_substituted, res)
4706 fn check_rustc_args_require_const(&self,
4710 // We're only interested in functions tagged with
4711 // #[rustc_args_required_const], so ignore anything that's not.
4712 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4716 // If our calling expression is indeed the function itself, we're good!
4717 // If not, generate an error that this can only be called directly.
4718 if let Node::Expr(expr) = self.tcx.hir().get(
4719 self.tcx.hir().get_parent_node(hir_id))
4721 if let ExprKind::Call(ref callee, ..) = expr.node {
4722 if callee.hir_id == hir_id {
4728 self.tcx.sess.span_err(span, "this function can only be invoked \
4729 directly, not through a function pointer");
4732 // Resolves `typ` by a single level if `typ` is a type variable.
4733 // If no resolution is possible, then an error is reported.
4734 // Numeric inference variables may be left unresolved.
4735 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4736 let ty = self.resolve_type_vars_with_obligations(ty);
4737 if !ty.is_ty_var() {
4740 if !self.is_tainted_by_errors() {
4741 self.need_type_info_err((**self).body_id, sp, ty)
4742 .note("type must be known at this point")
4745 self.demand_suptype(sp, self.tcx.types.err, ty);
4750 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4753 ctxt: BreakableCtxt<'tcx>,
4755 ) -> (BreakableCtxt<'tcx>, R) {
4758 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4759 index = enclosing_breakables.stack.len();
4760 enclosing_breakables.by_id.insert(id, index);
4761 enclosing_breakables.stack.push(ctxt);
4765 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4766 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4767 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4768 enclosing_breakables.stack.pop().expect("missing breakable context")
4773 /// Instantiate a QueryResponse in a probe context, without a
4774 /// good ObligationCause.
4775 fn probe_instantiate_query_response(
4778 original_values: &OriginalQueryValues<'tcx>,
4779 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4780 ) -> InferResult<'tcx, Ty<'tcx>>
4782 self.instantiate_query_response_and_region_obligations(
4783 &traits::ObligationCause::misc(span, self.body_id),
4789 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4790 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4791 let mut contained_in_place = false;
4793 while let hir::Node::Expr(parent_expr) =
4794 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4796 match &parent_expr.node {
4797 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4798 if lhs.hir_id == expr_id {
4799 contained_in_place = true;
4805 expr_id = parent_expr.hir_id;
4812 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4813 let own_counts = generics.own_counts();
4815 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4821 if own_counts.types == 0 {
4825 // Make a vector of booleans initially `false`; set to `true` when used.
4826 let mut types_used = vec![false; own_counts.types];
4828 for leaf_ty in ty.walk() {
4829 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4830 debug!("found use of ty param num {}", index);
4831 types_used[index as usize - own_counts.lifetimes] = true;
4832 } else if let ty::Error = leaf_ty.sty {
4833 // If there is already another error, do not emit
4834 // an error for not using a type parameter.
4835 assert!(tcx.sess.has_errors());
4840 let types = generics.params.iter().filter(|param| match param.kind {
4841 ty::GenericParamDefKind::Type { .. } => true,
4844 for (&used, param) in types_used.iter().zip(types) {
4846 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4847 let span = tcx.hir().span(id);
4848 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4849 .span_label(span, "unused type parameter")
4855 fn fatally_break_rust(sess: &Session) {
4856 let handler = sess.diagnostic();
4857 handler.span_bug_no_panic(
4859 "It looks like you're trying to break rust; would you like some ICE?",
4861 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4862 handler.note_without_error(
4863 "we would appreciate a joke overview: \
4864 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4866 handler.note_without_error(&format!("rustc {} running on {}",
4867 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4868 crate::session::config::host_triple(),
4872 fn potentially_plural_count(count: usize, word: &str) -> String {
4873 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })