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
85 mod generator_interior;
89 use crate::astconv::{AstConv, PathSeg};
90 use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
91 use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath};
92 use rustc::hir::def::{CtorOf, Res, DefKind};
93 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
94 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
95 use rustc::hir::itemlikevisit::ItemLikeVisitor;
96 use rustc::hir::ptr::P;
97 use crate::middle::lang_items;
98 use crate::namespace::Namespace;
99 use rustc::infer::{self, InferCtxt, InferOk, InferResult};
100 use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
101 use rustc_data_structures::indexed_vec::Idx;
102 use rustc_target::spec::abi::Abi;
103 use rustc::infer::opaque_types::OpaqueTypeDecl;
104 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
105 use rustc::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
106 use rustc::middle::region;
107 use rustc::mir::interpret::{ConstValue, GlobalId};
108 use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
110 self, AdtKind, CanonicalUserType, Ty, TyCtxt, Const, GenericParamDefKind,
111 ToPolyTraitRef, ToPredicate, RegionKind, UserType
113 use rustc::ty::adjustment::{
114 Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCast
116 use rustc::ty::fold::TypeFoldable;
117 use rustc::ty::query::Providers;
118 use rustc::ty::subst::{UnpackedKind, Subst, InternalSubsts, SubstsRef, UserSelfTy, UserSubsts};
119 use rustc::ty::util::{Representability, IntTypeExt, Discr};
120 use rustc::ty::layout::VariantIdx;
121 use syntax_pos::{self, BytePos, Span, MultiSpan};
122 use syntax_pos::hygiene::DesugaringKind;
125 use syntax::feature_gate::{GateIssue, emit_feature_err};
126 use syntax::source_map::{DUMMY_SP, original_sp};
127 use syntax::symbol::{kw, sym};
129 use std::cell::{Cell, RefCell, Ref, RefMut};
130 use std::collections::hash_map::Entry;
133 use std::mem::replace;
134 use std::ops::{self, Deref};
137 use crate::require_c_abi_if_c_variadic;
138 use crate::session::Session;
139 use crate::session::config::EntryFnType;
140 use crate::TypeAndSubsts;
142 use crate::util::captures::Captures;
143 use crate::util::common::{ErrorReported, indenter};
144 use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashSet, HirIdMap};
146 pub use self::Expectation::*;
147 use self::autoderef::Autoderef;
148 use self::callee::DeferredCallResolution;
149 use self::coercion::{CoerceMany, DynamicCoerceMany};
150 pub use self::compare_method::{compare_impl_method, compare_const_impl};
151 use self::method::{MethodCallee, SelfSource};
152 use self::TupleArgumentsFlag::*;
154 /// The type of a local binding, including the revealed type for anon types.
155 #[derive(Copy, Clone)]
156 pub struct LocalTy<'tcx> {
158 revealed_ty: Ty<'tcx>
161 /// A wrapper for `InferCtxt`'s `in_progress_tables` field.
162 #[derive(Copy, Clone)]
163 struct MaybeInProgressTables<'a, 'tcx> {
164 maybe_tables: Option<&'a RefCell<ty::TypeckTables<'tcx>>>,
167 impl<'a, 'tcx> MaybeInProgressTables<'a, 'tcx> {
168 fn borrow(self) -> Ref<'a, ty::TypeckTables<'tcx>> {
169 match self.maybe_tables {
170 Some(tables) => tables.borrow(),
172 bug!("MaybeInProgressTables: inh/fcx.tables.borrow() with no tables")
177 fn borrow_mut(self) -> RefMut<'a, ty::TypeckTables<'tcx>> {
178 match self.maybe_tables {
179 Some(tables) => tables.borrow_mut(),
181 bug!("MaybeInProgressTables: inh/fcx.tables.borrow_mut() with no tables")
187 /// Closures defined within the function. For example:
190 /// bar(move|| { ... })
193 /// Here, the function `foo()` and the closure passed to
194 /// `bar()` will each have their own `FnCtxt`, but they will
195 /// share the inherited fields.
196 pub struct Inherited<'a, 'tcx> {
197 infcx: InferCtxt<'a, 'tcx>,
199 tables: MaybeInProgressTables<'a, 'tcx>,
201 locals: RefCell<HirIdMap<LocalTy<'tcx>>>,
203 fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
205 // Some additional `Sized` obligations badly affect type inference.
206 // These obligations are added in a later stage of typeck.
207 deferred_sized_obligations: RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
209 // When we process a call like `c()` where `c` is a closure type,
210 // we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
211 // `FnOnce` closure. In that case, we defer full resolution of the
212 // call until upvar inference can kick in and make the
213 // decision. We keep these deferred resolutions grouped by the
214 // def-id of the closure, so that once we decide, we can easily go
215 // back and process them.
216 deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
218 deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
220 deferred_generator_interiors: RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
222 // Opaque types found in explicit return types and their
223 // associated fresh inference variable. Writeback resolves these
224 // variables to get the concrete type, which can be used to
225 // 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
226 opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
228 /// Each type parameter has an implicit region bound that
229 /// indicates it must outlive at least the function body (the user
230 /// may specify stronger requirements). This field indicates the
231 /// region of the callee. If it is `None`, then the parameter
232 /// environment is for an item or something where the "callee" is
234 implicit_region_bound: Option<ty::Region<'tcx>>,
236 body_id: Option<hir::BodyId>,
239 impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
240 type Target = InferCtxt<'a, 'tcx>;
241 fn deref(&self) -> &Self::Target {
246 /// When type-checking an expression, we propagate downward
247 /// whatever type hint we are able in the form of an `Expectation`.
248 #[derive(Copy, Clone, Debug)]
249 pub enum Expectation<'tcx> {
250 /// We know nothing about what type this expression should have.
253 /// This expression should have the type given (or some subtype).
254 ExpectHasType(Ty<'tcx>),
256 /// This expression will be cast to the `Ty`.
257 ExpectCastableToType(Ty<'tcx>),
259 /// This rvalue expression will be wrapped in `&` or `Box` and coerced
260 /// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
261 ExpectRvalueLikeUnsized(Ty<'tcx>),
264 impl<'a, 'tcx> Expectation<'tcx> {
265 // Disregard "castable to" expectations because they
266 // can lead us astray. Consider for example `if cond
267 // {22} else {c} as u8` -- if we propagate the
268 // "castable to u8" constraint to 22, it will pick the
269 // type 22u8, which is overly constrained (c might not
270 // be a u8). In effect, the problem is that the
271 // "castable to" expectation is not the tightest thing
272 // we can say, so we want to drop it in this case.
273 // The tightest thing we can say is "must unify with
274 // else branch". Note that in the case of a "has type"
275 // constraint, this limitation does not hold.
277 // If the expected type is just a type variable, then don't use
278 // an expected type. Otherwise, we might write parts of the type
279 // when checking the 'then' block which are incompatible with the
281 fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
283 ExpectHasType(ety) => {
284 let ety = fcx.shallow_resolve(ety);
285 if !ety.is_ty_var() {
291 ExpectRvalueLikeUnsized(ety) => {
292 ExpectRvalueLikeUnsized(ety)
298 /// Provides an expectation for an rvalue expression given an *optional*
299 /// hint, which is not required for type safety (the resulting type might
300 /// be checked higher up, as is the case with `&expr` and `box expr`), but
301 /// is useful in determining the concrete type.
303 /// The primary use case is where the expected type is a fat pointer,
304 /// like `&[isize]`. For example, consider the following statement:
306 /// let x: &[isize] = &[1, 2, 3];
308 /// In this case, the expected type for the `&[1, 2, 3]` expression is
309 /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
310 /// expectation `ExpectHasType([isize])`, that would be too strong --
311 /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
312 /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
313 /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
314 /// which still is useful, because it informs integer literals and the like.
315 /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
316 /// for examples of where this comes up,.
317 fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
318 match fcx.tcx.struct_tail_without_normalization(ty).sty {
319 ty::Slice(_) | ty::Str | ty::Dynamic(..) => {
320 ExpectRvalueLikeUnsized(ty)
322 _ => ExpectHasType(ty)
326 // Resolves `expected` by a single level if it is a variable. If
327 // there is no expected type or resolution is not possible (e.g.,
328 // no constraints yet present), just returns `None`.
329 fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
331 NoExpectation => NoExpectation,
332 ExpectCastableToType(t) => {
333 ExpectCastableToType(fcx.resolve_vars_if_possible(&t))
335 ExpectHasType(t) => {
336 ExpectHasType(fcx.resolve_vars_if_possible(&t))
338 ExpectRvalueLikeUnsized(t) => {
339 ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t))
344 fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
345 match self.resolve(fcx) {
346 NoExpectation => None,
347 ExpectCastableToType(ty) |
349 ExpectRvalueLikeUnsized(ty) => Some(ty),
353 /// It sometimes happens that we want to turn an expectation into
354 /// a **hard constraint** (i.e., something that must be satisfied
355 /// for the program to type-check). `only_has_type` will return
356 /// such a constraint, if it exists.
357 fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
358 match self.resolve(fcx) {
359 ExpectHasType(ty) => Some(ty),
360 NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
364 /// Like `only_has_type`, but instead of returning `None` if no
365 /// hard constraint exists, creates a fresh type variable.
366 fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
367 self.only_has_type(fcx)
369 fcx.next_ty_var(TypeVariableOrigin {
370 kind: TypeVariableOriginKind::MiscVariable,
377 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
384 fn maybe_mut_place(m: hir::Mutability) -> Self {
386 hir::MutMutable => Needs::MutPlace,
387 hir::MutImmutable => Needs::None,
392 #[derive(Copy, Clone)]
393 pub struct UnsafetyState {
395 pub unsafety: hir::Unsafety,
396 pub unsafe_push_count: u32,
401 pub fn function(unsafety: hir::Unsafety, def: hir::HirId) -> UnsafetyState {
402 UnsafetyState { def: def, unsafety: unsafety, unsafe_push_count: 0, from_fn: true }
405 pub fn recurse(&mut self, blk: &hir::Block) -> UnsafetyState {
406 match self.unsafety {
407 // If this unsafe, then if the outer function was already marked as
408 // unsafe we shouldn't attribute the unsafe'ness to the block. This
409 // way the block can be warned about instead of ignoring this
410 // extraneous block (functions are never warned about).
411 hir::Unsafety::Unsafe if self.from_fn => *self,
414 let (unsafety, def, count) = match blk.rules {
415 hir::PushUnsafeBlock(..) =>
416 (unsafety, blk.hir_id, self.unsafe_push_count.checked_add(1).unwrap()),
417 hir::PopUnsafeBlock(..) =>
418 (unsafety, blk.hir_id, self.unsafe_push_count.checked_sub(1).unwrap()),
419 hir::UnsafeBlock(..) =>
420 (hir::Unsafety::Unsafe, blk.hir_id, self.unsafe_push_count),
422 (unsafety, self.def, self.unsafe_push_count),
426 unsafe_push_count: count,
433 #[derive(Debug, Copy, Clone)]
439 /// Tracks whether executing a node may exit normally (versus
440 /// return/break/panic, which "diverge", leaving dead code in their
441 /// wake). Tracked semi-automatically (through type variables marked
442 /// as diverging), with some manual adjustments for control-flow
443 /// primitives (approximating a CFG).
444 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
446 /// Potentially unknown, some cases converge,
447 /// others require a CFG to determine them.
450 /// Definitely known to diverge and therefore
451 /// not reach the next sibling or its parent.
454 /// Same as `Always` but with a reachability
455 /// warning already emitted.
459 // Convenience impls for combinig `Diverges`.
461 impl ops::BitAnd for Diverges {
463 fn bitand(self, other: Self) -> Self {
464 cmp::min(self, other)
468 impl ops::BitOr for Diverges {
470 fn bitor(self, other: Self) -> Self {
471 cmp::max(self, other)
475 impl ops::BitAndAssign for Diverges {
476 fn bitand_assign(&mut self, other: Self) {
477 *self = *self & other;
481 impl ops::BitOrAssign for Diverges {
482 fn bitor_assign(&mut self, other: Self) {
483 *self = *self | other;
488 fn always(self) -> bool {
489 self >= Diverges::Always
493 pub struct BreakableCtxt<'tcx> {
496 // this is `null` for loops where break with a value is illegal,
497 // such as `while`, `for`, and `while let`
498 coerce: Option<DynamicCoerceMany<'tcx>>,
501 pub struct EnclosingBreakables<'tcx> {
502 stack: Vec<BreakableCtxt<'tcx>>,
503 by_id: HirIdMap<usize>,
506 impl<'tcx> EnclosingBreakables<'tcx> {
507 fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'tcx> {
508 let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
509 bug!("could not find enclosing breakable with id {}", target_id);
515 pub struct FnCtxt<'a, 'tcx> {
518 /// The parameter environment used for proving trait obligations
519 /// in this function. This can change when we descend into
520 /// closures (as they bring new things into scope), hence it is
521 /// not part of `Inherited` (as of the time of this writing,
522 /// closures do not yet change the environment, but they will
524 param_env: ty::ParamEnv<'tcx>,
526 /// Number of errors that had been reported when we started
527 /// checking this function. On exit, if we find that *more* errors
528 /// have been reported, we will skip regionck and other work that
529 /// expects the types within the function to be consistent.
530 // FIXME(matthewjasper) This should not exist, and it's not correct
531 // if type checking is run in parallel.
532 err_count_on_creation: usize,
534 ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
535 ret_coercion_span: RefCell<Option<Span>>,
537 yield_ty: Option<Ty<'tcx>>,
539 ps: RefCell<UnsafetyState>,
541 /// Whether the last checked node generates a divergence (e.g.,
542 /// `return` will set this to `Always`). In general, when entering
543 /// an expression or other node in the tree, the initial value
544 /// indicates whether prior parts of the containing expression may
545 /// have diverged. It is then typically set to `Maybe` (and the
546 /// old value remembered) for processing the subparts of the
547 /// current expression. As each subpart is processed, they may set
548 /// the flag to `Always`, etc. Finally, at the end, we take the
549 /// result and "union" it with the original value, so that when we
550 /// return the flag indicates if any subpart of the parent
551 /// expression (up to and including this part) has diverged. So,
552 /// if you read it after evaluating a subexpression `X`, the value
553 /// you get indicates whether any subexpression that was
554 /// evaluating up to and including `X` diverged.
556 /// We currently use this flag only for diagnostic purposes:
558 /// - To warn about unreachable code: if, after processing a
559 /// sub-expression but before we have applied the effects of the
560 /// current node, we see that the flag is set to `Always`, we
561 /// can issue a warning. This corresponds to something like
562 /// `foo(return)`; we warn on the `foo()` expression. (We then
563 /// update the flag to `WarnedAlways` to suppress duplicate
564 /// reports.) Similarly, if we traverse to a fresh statement (or
565 /// tail expression) from a `Always` setting, we will issue a
566 /// warning. This corresponds to something like `{return;
567 /// foo();}` or `{return; 22}`, where we would warn on the
570 /// An expression represents dead code if, after checking it,
571 /// the diverges flag is set to something other than `Maybe`.
572 diverges: Cell<Diverges>,
574 /// Whether any child nodes have any type errors.
575 has_errors: Cell<bool>,
577 enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
579 inh: &'a Inherited<'a, 'tcx>,
582 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
583 type Target = Inherited<'a, 'tcx>;
584 fn deref(&self) -> &Self::Target {
589 /// Helper type of a temporary returned by `Inherited::build(...)`.
590 /// Necessary because we can't write the following bound:
591 /// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
592 pub struct InheritedBuilder<'tcx> {
593 infcx: infer::InferCtxtBuilder<'tcx>,
597 impl Inherited<'_, 'tcx> {
598 pub fn build(tcx: TyCtxt<'tcx>, def_id: DefId) -> InheritedBuilder<'tcx> {
599 let hir_id_root = if def_id.is_local() {
600 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
601 DefId::local(hir_id.owner)
607 infcx: tcx.infer_ctxt().with_fresh_in_progress_tables(hir_id_root),
613 impl<'tcx> InheritedBuilder<'tcx> {
614 fn enter<F, R>(&mut self, f: F) -> R
616 F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
618 let def_id = self.def_id;
619 self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
623 impl Inherited<'a, 'tcx> {
624 fn new(infcx: InferCtxt<'a, 'tcx>, def_id: DefId) -> Self {
626 let item_id = tcx.hir().as_local_hir_id(def_id);
627 let body_id = item_id.and_then(|id| tcx.hir().maybe_body_owned_by(id));
628 let implicit_region_bound = body_id.map(|body_id| {
629 let body = tcx.hir().body(body_id);
630 tcx.mk_region(ty::ReScope(region::Scope {
631 id: body.value.hir_id.local_id,
632 data: region::ScopeData::CallSite
637 tables: MaybeInProgressTables {
638 maybe_tables: infcx.in_progress_tables,
641 fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
642 locals: RefCell::new(Default::default()),
643 deferred_sized_obligations: RefCell::new(Vec::new()),
644 deferred_call_resolutions: RefCell::new(Default::default()),
645 deferred_cast_checks: RefCell::new(Vec::new()),
646 deferred_generator_interiors: RefCell::new(Vec::new()),
647 opaque_types: RefCell::new(Default::default()),
648 implicit_region_bound,
653 fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
654 debug!("register_predicate({:?})", obligation);
655 if obligation.has_escaping_bound_vars() {
656 span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}",
661 .register_predicate_obligation(self, obligation);
664 fn register_predicates<I>(&self, obligations: I)
665 where I: IntoIterator<Item = traits::PredicateObligation<'tcx>>
667 for obligation in obligations {
668 self.register_predicate(obligation);
672 fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
673 self.register_predicates(infer_ok.obligations);
677 fn normalize_associated_types_in<T>(&self,
680 param_env: ty::ParamEnv<'tcx>,
682 where T : TypeFoldable<'tcx>
684 let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
685 self.register_infer_ok_obligations(ok)
689 struct CheckItemTypesVisitor<'tcx> {
693 impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
694 fn visit_item(&mut self, i: &'tcx hir::Item) {
695 check_item_type(self.tcx, i);
697 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
698 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
701 pub fn check_wf_new(tcx: TyCtxt<'_>) {
702 let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
703 tcx.hir().krate().par_visit_all_item_likes(&mut visit);
706 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
707 tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
710 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
711 debug_assert!(crate_num == LOCAL_CRATE);
712 tcx.par_body_owners(|body_owner_def_id| {
713 tcx.ensure().typeck_tables_of(body_owner_def_id);
717 fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
718 wfcheck::check_item_well_formed(tcx, def_id);
721 fn check_trait_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
722 wfcheck::check_trait_item(tcx, def_id);
725 fn check_impl_item_well_formed(tcx: TyCtxt<'_>, def_id: DefId) {
726 wfcheck::check_impl_item(tcx, def_id);
729 pub fn provide(providers: &mut Providers<'_>) {
730 method::provide(providers);
731 *providers = Providers {
737 check_item_well_formed,
738 check_trait_item_well_formed,
739 check_impl_item_well_formed,
740 check_mod_item_types,
745 fn adt_destructor(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::Destructor> {
746 tcx.calculate_dtor(def_id, &mut dropck::check_drop_impl)
749 /// If this `DefId` is a "primary tables entry", returns
750 /// `Some((body_id, header, decl))` with information about
751 /// it's body-id, fn-header and fn-decl (if any). Otherwise,
754 /// If this function returns `Some`, then `typeck_tables(def_id)` will
755 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
756 /// may not succeed. In some cases where this function returns `None`
757 /// (notably closures), `typeck_tables(def_id)` would wind up
758 /// redirecting to the owning function.
762 ) -> Option<(hir::BodyId, Option<&hir::Ty>, Option<&hir::FnHeader>, Option<&hir::FnDecl>)> {
763 match tcx.hir().get(id) {
764 Node::Item(item) => {
766 hir::ItemKind::Const(ref ty, body) |
767 hir::ItemKind::Static(ref ty, _, body) =>
768 Some((body, Some(ty), None, None)),
769 hir::ItemKind::Fn(ref decl, ref header, .., body) =>
770 Some((body, None, Some(header), Some(decl))),
775 Node::TraitItem(item) => {
777 hir::TraitItemKind::Const(ref ty, Some(body)) =>
778 Some((body, Some(ty), None, None)),
779 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
780 Some((body, None, Some(&sig.header), Some(&sig.decl))),
785 Node::ImplItem(item) => {
787 hir::ImplItemKind::Const(ref ty, body) =>
788 Some((body, Some(ty), None, None)),
789 hir::ImplItemKind::Method(ref sig, body) =>
790 Some((body, None, Some(&sig.header), Some(&sig.decl))),
795 Node::AnonConst(constant) => Some((constant.body, None, None, None)),
800 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
801 // Closures' tables come from their outermost function,
802 // as they are part of the same "inference environment".
803 let outer_def_id = tcx.closure_base_def_id(def_id);
804 if outer_def_id != def_id {
805 return tcx.has_typeck_tables(outer_def_id);
808 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
809 primary_body_of(tcx, id).is_some()
812 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
813 &*tcx.typeck_tables_of(def_id).used_trait_imports
816 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
817 // Closures' tables come from their outermost function,
818 // as they are part of the same "inference environment".
819 let outer_def_id = tcx.closure_base_def_id(def_id);
820 if outer_def_id != def_id {
821 return tcx.typeck_tables_of(outer_def_id);
824 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
825 let span = tcx.hir().span(id);
827 // Figure out what primary body this item has.
828 let (body_id, body_ty, fn_header, fn_decl) = primary_body_of(tcx, id)
830 span_bug!(span, "can't type-check body of {:?}", def_id);
832 let body = tcx.hir().body(body_id);
834 let tables = Inherited::build(tcx, def_id).enter(|inh| {
835 let param_env = tcx.param_env(def_id);
836 let fcx = if let (Some(header), Some(decl)) = (fn_header, fn_decl) {
837 let fn_sig = if crate::collect::get_infer_ret_ty(&decl.output).is_some() {
838 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
839 AstConv::ty_of_fn(&fcx, header.unsafety, header.abi, decl)
844 check_abi(tcx, span, fn_sig.abi());
846 // Compute the fty from point of view of inside the fn.
848 tcx.liberate_late_bound_regions(def_id, &fn_sig);
850 inh.normalize_associated_types_in(body.value.span,
855 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
858 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
859 let expected_type = body_ty.and_then(|ty| match ty.node {
860 hir::TyKind::Infer => Some(AstConv::ast_ty_to_ty(&fcx, ty)),
862 }).unwrap_or_else(|| tcx.type_of(def_id));
863 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
864 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
866 let revealed_ty = if tcx.features().impl_trait_in_bindings {
867 fcx.instantiate_opaque_types_from_value(
876 // Gather locals in statics (because of block expressions).
877 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
879 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
881 fcx.write_ty(id, revealed_ty);
886 // All type checking constraints were added, try to fallback unsolved variables.
887 fcx.select_obligations_where_possible(false);
888 let mut fallback_has_occurred = false;
889 for ty in &fcx.unsolved_variables() {
890 fallback_has_occurred |= fcx.fallback_if_possible(ty);
892 fcx.select_obligations_where_possible(fallback_has_occurred);
894 // Even though coercion casts provide type hints, we check casts after fallback for
895 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
898 // Closure and generator analysis may run after fallback
899 // because they don't constrain other type variables.
900 fcx.closure_analyze(body);
901 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
902 fcx.resolve_generator_interiors(def_id);
904 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
905 let ty = fcx.normalize_ty(span, ty);
906 fcx.require_type_is_sized(ty, span, code);
908 fcx.select_all_obligations_or_error();
910 if fn_decl.is_some() {
911 fcx.regionck_fn(id, body);
913 fcx.regionck_expr(body);
916 fcx.resolve_type_vars_in_body(body)
919 // Consistency check our TypeckTables instance can hold all ItemLocalIds
920 // it will need to hold.
921 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
926 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
927 if !tcx.sess.target.target.is_abi_supported(abi) {
928 struct_span_err!(tcx.sess, span, E0570,
929 "The ABI `{}` is not supported for the current target", abi).emit()
933 struct GatherLocalsVisitor<'a, 'tcx> {
934 fcx: &'a FnCtxt<'a, 'tcx>,
935 parent_id: hir::HirId,
938 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
939 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
942 // infer the variable's type
943 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
944 kind: TypeVariableOriginKind::TypeInference,
947 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
954 // take type that the user specified
955 self.fcx.locals.borrow_mut().insert(nid, typ);
962 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
963 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
964 NestedVisitorMap::None
967 // Add explicitly-declared locals.
968 fn visit_local(&mut self, local: &'tcx hir::Local) {
969 let local_ty = match local.ty {
971 let o_ty = self.fcx.to_ty(&ty);
973 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
974 self.fcx.instantiate_opaque_types_from_value(
983 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
984 &UserType::Ty(revealed_ty)
986 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
987 ty.hir_id, o_ty, revealed_ty, c_ty);
988 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
990 Some(LocalTy { decl_ty: o_ty, revealed_ty })
994 self.assign(local.span, local.hir_id, local_ty);
996 debug!("local variable {:?} is assigned type {}",
998 self.fcx.ty_to_string(
999 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
1000 intravisit::walk_local(self, local);
1003 // Add pattern bindings.
1004 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
1005 if let PatKind::Binding(_, _, ident, _) = p.node {
1006 let var_ty = self.assign(p.span, p.hir_id, None);
1008 if !self.fcx.tcx.features().unsized_locals {
1009 self.fcx.require_type_is_sized(var_ty, p.span,
1010 traits::VariableType(p.hir_id));
1013 debug!("pattern binding {} is assigned to {} with type {:?}",
1015 self.fcx.ty_to_string(
1016 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1019 intravisit::walk_pat(self, p);
1022 // Don't descend into the bodies of nested closures
1025 _: intravisit::FnKind<'tcx>,
1026 _: &'tcx hir::FnDecl,
1033 /// When `check_fn` is invoked on a generator (i.e., a body that
1034 /// includes yield), it returns back some information about the yield
1036 struct GeneratorTypes<'tcx> {
1037 /// Type of value that is yielded.
1040 /// Types that are captured (see `GeneratorInterior` for more).
1043 /// Indicates if the generator is movable or static (immovable).
1044 movability: hir::GeneratorMovability,
1047 /// Helper used for fns and closures. Does the grungy work of checking a function
1048 /// body and returns the function context used for that purpose, since in the case of a fn item
1049 /// there is still a bit more to do.
1052 /// * inherited: other fields inherited from the enclosing fn (if any)
1053 fn check_fn<'a, 'tcx>(
1054 inherited: &'a Inherited<'a, 'tcx>,
1055 param_env: ty::ParamEnv<'tcx>,
1056 fn_sig: ty::FnSig<'tcx>,
1057 decl: &'tcx hir::FnDecl,
1059 body: &'tcx hir::Body,
1060 can_be_generator: Option<hir::GeneratorMovability>,
1061 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1062 let mut fn_sig = fn_sig.clone();
1064 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1066 // Create the function context. This is either derived from scratch or,
1067 // in the case of closures, based on the outer context.
1068 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1069 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1071 let declared_ret_ty = fn_sig.output();
1072 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1073 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1078 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1079 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1080 fn_sig = fcx.tcx.mk_fn_sig(
1081 fn_sig.inputs().iter().cloned(),
1088 let span = body.value.span;
1090 if body.generator_kind.is_some() && can_be_generator.is_some() {
1091 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1092 kind: TypeVariableOriginKind::TypeInference,
1095 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1096 fcx.yield_ty = Some(yield_ty);
1099 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1100 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1101 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1103 // Add formal parameters.
1104 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1105 // Check the pattern.
1106 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1107 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1109 // Check that argument is Sized.
1110 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1111 // for simple cases like `fn foo(x: Trait)`,
1112 // where we would error once on the parameter as a whole, and once on the binding `x`.
1113 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1114 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1117 fcx.write_ty(arg.hir_id, arg_ty);
1120 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1122 fcx.check_return_expr(&body.value);
1124 // We insert the deferred_generator_interiors entry after visiting the body.
1125 // This ensures that all nested generators appear before the entry of this generator.
1126 // resolve_generator_interiors relies on this property.
1127 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1128 let interior = fcx.next_ty_var(TypeVariableOrigin {
1129 kind: TypeVariableOriginKind::MiscVariable,
1132 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1133 Some(GeneratorTypes {
1134 yield_ty: fcx.yield_ty.unwrap(),
1136 movability: can_be_generator.unwrap(),
1142 // Finalize the return check by taking the LUB of the return types
1143 // we saw and assigning it to the expected return type. This isn't
1144 // really expected to fail, since the coercions would have failed
1145 // earlier when trying to find a LUB.
1147 // However, the behavior around `!` is sort of complex. In the
1148 // event that the `actual_return_ty` comes back as `!`, that
1149 // indicates that the fn either does not return or "returns" only
1150 // values of type `!`. In this case, if there is an expected
1151 // return type that is *not* `!`, that should be ok. But if the
1152 // return type is being inferred, we want to "fallback" to `!`:
1154 // let x = move || panic!();
1156 // To allow for that, I am creating a type variable with diverging
1157 // fallback. This was deemed ever so slightly better than unifying
1158 // the return value with `!` because it allows for the caller to
1159 // make more assumptions about the return type (e.g., they could do
1161 // let y: Option<u32> = Some(x());
1163 // which would then cause this return type to become `u32`, not
1165 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1166 let mut actual_return_ty = coercion.complete(&fcx);
1167 if actual_return_ty.is_never() {
1168 actual_return_ty = fcx.next_diverging_ty_var(
1169 TypeVariableOrigin {
1170 kind: TypeVariableOriginKind::DivergingFn,
1175 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1177 // Check that the main return type implements the termination trait.
1178 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1179 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1180 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1181 if main_id == fn_id {
1182 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1183 let trait_ref = ty::TraitRef::new(term_id, substs);
1184 let return_ty_span = decl.output.span();
1185 let cause = traits::ObligationCause::new(
1186 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1188 inherited.register_predicate(
1189 traits::Obligation::new(
1190 cause, param_env, trait_ref.to_predicate()));
1195 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1196 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1197 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1198 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1199 // at this point we don't care if there are duplicate handlers or if the handler has
1200 // the wrong signature as this value we'll be used when writing metadata and that
1201 // only happens if compilation succeeded
1202 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1204 if declared_ret_ty.sty != ty::Never {
1205 fcx.tcx.sess.span_err(
1207 "return type should be `!`",
1211 let inputs = fn_sig.inputs();
1212 let span = fcx.tcx.hir().span(fn_id);
1213 if inputs.len() == 1 {
1214 let arg_is_panic_info = match inputs[0].sty {
1215 ty::Ref(region, ty, mutbl) => match ty.sty {
1216 ty::Adt(ref adt, _) => {
1217 adt.did == panic_info_did &&
1218 mutbl == hir::Mutability::MutImmutable &&
1219 *region != RegionKind::ReStatic
1226 if !arg_is_panic_info {
1227 fcx.tcx.sess.span_err(
1228 decl.inputs[0].span,
1229 "argument should be `&PanicInfo`",
1233 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1234 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1235 if !generics.params.is_empty() {
1236 fcx.tcx.sess.span_err(
1238 "should have no type parameters",
1244 let span = fcx.tcx.sess.source_map().def_span(span);
1245 fcx.tcx.sess.span_err(span, "function should have one argument");
1248 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1253 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1254 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1255 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1256 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1257 if declared_ret_ty.sty != ty::Never {
1258 fcx.tcx.sess.span_err(
1260 "return type should be `!`",
1264 let inputs = fn_sig.inputs();
1265 let span = fcx.tcx.hir().span(fn_id);
1266 if inputs.len() == 1 {
1267 let arg_is_alloc_layout = match inputs[0].sty {
1268 ty::Adt(ref adt, _) => {
1269 adt.did == alloc_layout_did
1274 if !arg_is_alloc_layout {
1275 fcx.tcx.sess.span_err(
1276 decl.inputs[0].span,
1277 "argument should be `Layout`",
1281 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1282 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1283 if !generics.params.is_empty() {
1284 fcx.tcx.sess.span_err(
1286 "`#[alloc_error_handler]` function should have no type \
1293 let span = fcx.tcx.sess.source_map().def_span(span);
1294 fcx.tcx.sess.span_err(span, "function should have one argument");
1297 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1305 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1306 let def_id = tcx.hir().local_def_id(id);
1307 let def = tcx.adt_def(def_id);
1308 def.destructor(tcx); // force the destructor to be evaluated
1309 check_representable(tcx, span, def_id);
1311 if def.repr.simd() {
1312 check_simd(tcx, span, def_id);
1315 check_transparent(tcx, span, def_id);
1316 check_packed(tcx, span, def_id);
1319 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1320 let def_id = tcx.hir().local_def_id(id);
1321 let def = tcx.adt_def(def_id);
1322 def.destructor(tcx); // force the destructor to be evaluated
1323 check_representable(tcx, span, def_id);
1324 check_transparent(tcx, span, def_id);
1325 check_packed(tcx, span, def_id);
1328 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1329 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1330 let mut err = struct_span_err!(
1331 tcx.sess, span, E0720,
1332 "opaque type expands to a recursive type",
1334 err.span_label(span, "expands to a recursive type");
1335 if let ty::Opaque(..) = partially_expanded_type.sty {
1336 err.note("type resolves to itself");
1338 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1344 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1346 "check_item_type(it.hir_id={}, it.name={})",
1348 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1350 let _indenter = indenter();
1352 // Consts can play a role in type-checking, so they are included here.
1353 hir::ItemKind::Static(..) => {
1354 let def_id = tcx.hir().local_def_id(it.hir_id);
1355 tcx.typeck_tables_of(def_id);
1356 maybe_check_static_with_link_section(tcx, def_id, it.span);
1358 hir::ItemKind::Const(..) => {
1359 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1361 hir::ItemKind::Enum(ref enum_definition, _) => {
1362 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1364 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1365 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1366 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1367 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1368 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1369 check_impl_items_against_trait(
1376 let trait_def_id = impl_trait_ref.def_id;
1377 check_on_unimplemented(tcx, trait_def_id, it);
1380 hir::ItemKind::Trait(..) => {
1381 let def_id = tcx.hir().local_def_id(it.hir_id);
1382 check_on_unimplemented(tcx, def_id, it);
1384 hir::ItemKind::Struct(..) => {
1385 check_struct(tcx, it.hir_id, it.span);
1387 hir::ItemKind::Union(..) => {
1388 check_union(tcx, it.hir_id, it.span);
1390 hir::ItemKind::Existential(..) => {
1391 let def_id = tcx.hir().local_def_id(it.hir_id);
1393 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1394 check_opaque(tcx, def_id, substs, it.span);
1396 hir::ItemKind::Ty(..) => {
1397 let def_id = tcx.hir().local_def_id(it.hir_id);
1398 let pty_ty = tcx.type_of(def_id);
1399 let generics = tcx.generics_of(def_id);
1400 check_bounds_are_used(tcx, &generics, pty_ty);
1402 hir::ItemKind::ForeignMod(ref m) => {
1403 check_abi(tcx, it.span, m.abi);
1405 if m.abi == Abi::RustIntrinsic {
1406 for item in &m.items {
1407 intrinsic::check_intrinsic_type(tcx, item);
1409 } else if m.abi == Abi::PlatformIntrinsic {
1410 for item in &m.items {
1411 intrinsic::check_platform_intrinsic_type(tcx, item);
1414 for item in &m.items {
1415 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1416 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1417 let mut err = struct_span_err!(
1421 "foreign items may not have type parameters"
1423 err.span_label(item.span, "can't have type parameters");
1424 // FIXME: once we start storing spans for type arguments, turn this into a
1427 "use specialization instead of type parameters by replacing them \
1428 with concrete types like `u32`",
1433 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1434 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1439 _ => { /* nothing to do */ }
1443 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1444 // Only restricted on wasm32 target for now
1445 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1449 // If `#[link_section]` is missing, then nothing to verify
1450 let attrs = tcx.codegen_fn_attrs(id);
1451 if attrs.link_section.is_none() {
1455 // For the wasm32 target statics with `#[link_section]` are placed into custom
1456 // sections of the final output file, but this isn't link custom sections of
1457 // other executable formats. Namely we can only embed a list of bytes,
1458 // nothing with pointers to anything else or relocations. If any relocation
1459 // show up, reject them here.
1460 // `#[link_section]` may contain arbitrary, or even undefined bytes, but it is
1461 // the consumer's responsibility to ensure all bytes that have been read
1462 // have defined values.
1463 let instance = ty::Instance::mono(tcx, id);
1464 let cid = GlobalId {
1468 let param_env = ty::ParamEnv::reveal_all();
1469 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1470 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1473 bug!("Matching on non-ByRef static")
1475 if alloc.relocations.len() != 0 {
1476 let msg = "statics with a custom `#[link_section]` must be a \
1477 simple list of bytes on the wasm target with no \
1478 extra levels of indirection such as references";
1479 tcx.sess.span_err(span, msg);
1484 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1485 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1486 // an error would be reported if this fails.
1487 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1490 fn report_forbidden_specialization(
1492 impl_item: &hir::ImplItem,
1495 let mut err = struct_span_err!(
1496 tcx.sess, impl_item.span, E0520,
1497 "`{}` specializes an item from a parent `impl`, but \
1498 that item is not marked `default`",
1500 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1503 match tcx.span_of_impl(parent_impl) {
1505 err.span_label(span, "parent `impl` is here");
1506 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1510 err.note(&format!("parent implementation is in crate `{}`", cname));
1517 fn check_specialization_validity<'tcx>(
1519 trait_def: &ty::TraitDef,
1520 trait_item: &ty::AssocItem,
1522 impl_item: &hir::ImplItem,
1524 let ancestors = trait_def.ancestors(tcx, impl_id);
1526 let kind = match impl_item.node {
1527 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1528 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1529 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1530 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1533 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1534 .map(|node_item| node_item.map(|parent| parent.defaultness));
1536 if let Some(parent) = parent {
1537 if tcx.impl_item_is_final(&parent) {
1538 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1544 fn check_impl_items_against_trait<'tcx>(
1548 impl_trait_ref: ty::TraitRef<'tcx>,
1549 impl_item_refs: &[hir::ImplItemRef],
1551 let impl_span = tcx.sess.source_map().def_span(impl_span);
1553 // If the trait reference itself is erroneous (so the compilation is going
1554 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1555 // isn't populated for such impls.
1556 if impl_trait_ref.references_error() { return; }
1558 // Locate trait definition and items
1559 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1560 let mut overridden_associated_type = None;
1562 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1564 // Check existing impl methods to see if they are both present in trait
1565 // and compatible with trait signature
1566 for impl_item in impl_items() {
1567 let ty_impl_item = tcx.associated_item(
1568 tcx.hir().local_def_id(impl_item.hir_id));
1569 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1570 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1571 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1573 // Not compatible, but needed for the error message
1574 tcx.associated_items(impl_trait_ref.def_id)
1575 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1578 // Check that impl definition matches trait definition
1579 if let Some(ty_trait_item) = ty_trait_item {
1580 match impl_item.node {
1581 hir::ImplItemKind::Const(..) => {
1582 // Find associated const definition.
1583 if ty_trait_item.kind == ty::AssocKind::Const {
1584 compare_const_impl(tcx,
1590 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1591 "item `{}` is an associated const, \
1592 which doesn't match its trait `{}`",
1595 err.span_label(impl_item.span, "does not match trait");
1596 // We can only get the spans from local trait definition
1597 // Same for E0324 and E0325
1598 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1599 err.span_label(trait_span, "item in trait");
1604 hir::ImplItemKind::Method(..) => {
1605 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1606 if ty_trait_item.kind == ty::AssocKind::Method {
1607 compare_impl_method(tcx,
1614 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1615 "item `{}` is an associated method, \
1616 which doesn't match its trait `{}`",
1619 err.span_label(impl_item.span, "does not match trait");
1620 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1621 err.span_label(trait_span, "item in trait");
1626 hir::ImplItemKind::Existential(..) |
1627 hir::ImplItemKind::Type(_) => {
1628 if ty_trait_item.kind == ty::AssocKind::Type {
1629 if ty_trait_item.defaultness.has_value() {
1630 overridden_associated_type = Some(impl_item);
1633 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1634 "item `{}` is an associated type, \
1635 which doesn't match its trait `{}`",
1638 err.span_label(impl_item.span, "does not match trait");
1639 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1640 err.span_label(trait_span, "item in trait");
1647 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1651 // Check for missing items from trait
1652 let mut missing_items = Vec::new();
1653 let mut invalidated_items = Vec::new();
1654 let associated_type_overridden = overridden_associated_type.is_some();
1655 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1656 let is_implemented = trait_def.ancestors(tcx, impl_id)
1657 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1659 .map(|node_item| !node_item.node.is_from_trait())
1662 if !is_implemented && !tcx.impl_is_default(impl_id) {
1663 if !trait_item.defaultness.has_value() {
1664 missing_items.push(trait_item);
1665 } else if associated_type_overridden {
1666 invalidated_items.push(trait_item.ident);
1671 if !missing_items.is_empty() {
1672 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1673 "not all trait items implemented, missing: `{}`",
1674 missing_items.iter()
1675 .map(|trait_item| trait_item.ident.to_string())
1676 .collect::<Vec<_>>().join("`, `"));
1677 err.span_label(impl_span, format!("missing `{}` in implementation",
1678 missing_items.iter()
1679 .map(|trait_item| trait_item.ident.to_string())
1680 .collect::<Vec<_>>().join("`, `")));
1681 for trait_item in missing_items {
1682 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1683 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1685 err.note_trait_signature(trait_item.ident.to_string(),
1686 trait_item.signature(tcx));
1692 if !invalidated_items.is_empty() {
1693 let invalidator = overridden_associated_type.unwrap();
1694 span_err!(tcx.sess, invalidator.span, E0399,
1695 "the following trait items need to be reimplemented \
1696 as `{}` was overridden: `{}`",
1698 invalidated_items.iter()
1699 .map(|name| name.to_string())
1700 .collect::<Vec<_>>().join("`, `"))
1704 /// Checks whether a type can be represented in memory. In particular, it
1705 /// identifies types that contain themselves without indirection through a
1706 /// pointer, which would mean their size is unbounded.
1707 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1708 let rty = tcx.type_of(item_def_id);
1710 // Check that it is possible to represent this type. This call identifies
1711 // (1) types that contain themselves and (2) types that contain a different
1712 // recursive type. It is only necessary to throw an error on those that
1713 // contain themselves. For case 2, there must be an inner type that will be
1714 // caught by case 1.
1715 match rty.is_representable(tcx, sp) {
1716 Representability::SelfRecursive(spans) => {
1717 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1719 err.span_label(span, "recursive without indirection");
1724 Representability::Representable | Representability::ContainsRecursive => (),
1729 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1730 let t = tcx.type_of(def_id);
1731 if let ty::Adt(def, substs) = t.sty {
1732 if def.is_struct() {
1733 let fields = &def.non_enum_variant().fields;
1734 if fields.is_empty() {
1735 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1738 let e = fields[0].ty(tcx, substs);
1739 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1740 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1741 .span_label(sp, "SIMD elements must have the same type")
1746 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1747 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1749 span_err!(tcx.sess, sp, E0077,
1750 "SIMD vector element type should be machine type");
1758 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1759 let repr = tcx.adt_def(def_id).repr;
1761 for attr in tcx.get_attrs(def_id).iter() {
1762 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1763 if let attr::ReprPacked(pack) = r {
1764 if pack != repr.pack {
1765 struct_span_err!(tcx.sess, sp, E0634,
1766 "type has conflicting packed representation hints").emit();
1772 struct_span_err!(tcx.sess, sp, E0587,
1773 "type has conflicting packed and align representation hints").emit();
1775 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1776 struct_span_err!(tcx.sess, sp, E0588,
1777 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1782 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1783 let t = tcx.type_of(def_id);
1784 if stack.contains(&def_id) {
1785 debug!("check_packed_inner: {:?} is recursive", t);
1788 if let ty::Adt(def, substs) = t.sty {
1789 if def.is_struct() || def.is_union() {
1790 if tcx.adt_def(def.did).repr.align > 0 {
1793 // push struct def_id before checking fields
1795 for field in &def.non_enum_variant().fields {
1796 let f = field.ty(tcx, substs);
1797 if let ty::Adt(def, _) = f.sty {
1798 if check_packed_inner(tcx, def.did, stack) {
1803 // only need to pop if not early out
1810 /// Emit an error when encountering more or less than one variant in a transparent enum.
1811 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1812 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1813 tcx.hir().span_if_local(variant.def_id).unwrap()
1816 "needs exactly one variant, but has {}",
1819 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1820 err.span_label(sp, &msg);
1821 if let &[ref start.., ref end] = &variant_spans[..] {
1822 for variant_span in start {
1823 err.span_label(*variant_span, "");
1825 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1830 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1832 fn bad_non_zero_sized_fields<'tcx>(
1834 adt: &'tcx ty::AdtDef,
1836 field_spans: impl Iterator<Item = Span>,
1839 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1840 let mut err = struct_span_err!(
1844 "{}transparent {} {}",
1845 if adt.is_enum() { "the variant of a " } else { "" },
1849 err.span_label(sp, &msg);
1850 for sp in field_spans {
1851 err.span_label(sp, "this field is non-zero-sized");
1856 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1857 let adt = tcx.adt_def(def_id);
1858 if !adt.repr.transparent() {
1861 let sp = tcx.sess.source_map().def_span(sp);
1864 if !tcx.features().transparent_enums {
1866 &tcx.sess.parse_sess,
1867 sym::transparent_enums,
1869 GateIssue::Language,
1870 "transparent enums are unstable",
1873 if adt.variants.len() != 1 {
1874 bad_variant_count(tcx, adt, sp, def_id);
1875 if adt.variants.is_empty() {
1876 // Don't bother checking the fields. No variants (and thus no fields) exist.
1882 if adt.is_union() && !tcx.features().transparent_unions {
1883 emit_feature_err(&tcx.sess.parse_sess,
1884 sym::transparent_unions,
1886 GateIssue::Language,
1887 "transparent unions are unstable");
1890 // For each field, figure out if it's known to be a ZST and align(1)
1891 let field_infos = adt.all_fields().map(|field| {
1892 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1893 let param_env = tcx.param_env(field.did);
1894 let layout = tcx.layout_of(param_env.and(ty));
1895 // We are currently checking the type this field came from, so it must be local
1896 let span = tcx.hir().span_if_local(field.did).unwrap();
1897 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1898 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1902 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1907 let non_zst_count = non_zst_fields.clone().count();
1908 if non_zst_count != 1 {
1909 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1911 for (span, zst, align1) in field_infos {
1917 "zero-sized field in transparent {} has alignment larger than 1",
1919 ).span_label(span, "has alignment larger than 1").emit();
1924 #[allow(trivial_numeric_casts)]
1925 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1926 let def_id = tcx.hir().local_def_id(id);
1927 let def = tcx.adt_def(def_id);
1928 def.destructor(tcx); // force the destructor to be evaluated
1931 let attributes = tcx.get_attrs(def_id);
1932 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1934 tcx.sess, attr.span, E0084,
1935 "unsupported representation for zero-variant enum")
1936 .span_label(sp, "zero-variant enum")
1941 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1942 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1943 if !tcx.features().repr128 {
1944 emit_feature_err(&tcx.sess.parse_sess,
1947 GateIssue::Language,
1948 "repr with 128-bit type is unstable");
1953 if let Some(ref e) = v.node.disr_expr {
1954 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
1958 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1960 |var: &hir::Variant| match var.node.data {
1961 hir::VariantData::Unit(..) => true,
1965 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1966 let has_non_units = vs.iter().any(|var| !is_unit(var));
1967 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1968 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1970 if disr_non_unit || (disr_units && has_non_units) {
1971 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1972 "`#[repr(inttype)]` must be specified");
1977 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1978 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1979 // Check for duplicate discriminant values
1980 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1981 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1982 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1983 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1984 let i_span = match variant_i.node.disr_expr {
1985 Some(ref expr) => tcx.hir().span(expr.hir_id),
1986 None => tcx.hir().span(variant_i_hir_id)
1988 let span = match v.node.disr_expr {
1989 Some(ref expr) => tcx.hir().span(expr.hir_id),
1992 struct_span_err!(tcx.sess, span, E0081,
1993 "discriminant value `{}` already exists", disr_vals[i])
1994 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1995 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1998 disr_vals.push(discr);
2001 check_representable(tcx, sp, def_id);
2002 check_transparent(tcx, sp, def_id);
2005 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
2006 span_err!(tcx.sess, span, E0533,
2007 "expected unit struct/variant or constant, found {} `{}`",
2009 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
2012 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2013 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2017 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2018 -> &'tcx ty::GenericPredicates<'tcx>
2021 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2022 let item_id = tcx.hir().ty_param_owner(hir_id);
2023 let item_def_id = tcx.hir().local_def_id(item_id);
2024 let generics = tcx.generics_of(item_def_id);
2025 let index = generics.param_def_id_to_index[&def_id];
2026 tcx.arena.alloc(ty::GenericPredicates {
2028 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2030 ty::Predicate::Trait(ref data)
2031 if data.skip_binder().self_ty().is_param(index) => {
2032 // HACK(eddyb) should get the original `Span`.
2033 let span = tcx.def_span(def_id);
2034 Some((predicate, span))
2044 def: Option<&ty::GenericParamDef>,
2046 ) -> Option<ty::Region<'tcx>> {
2048 Some(def) => infer::EarlyBoundRegion(span, def.name),
2049 None => infer::MiscVariable(span)
2051 Some(self.next_region_var(v))
2054 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2055 if let Some(param) = param {
2056 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2061 self.next_ty_var(TypeVariableOrigin {
2062 kind: TypeVariableOriginKind::TypeInference,
2071 param: Option<&ty::GenericParamDef>,
2073 ) -> &'tcx Const<'tcx> {
2074 if let Some(param) = param {
2075 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2080 self.next_const_var(ty, ConstVariableOrigin {
2081 kind: ConstVariableOriginKind::ConstInference,
2087 fn projected_ty_from_poly_trait_ref(&self,
2090 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2093 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2095 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2099 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2102 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2103 if ty.has_escaping_bound_vars() {
2104 ty // FIXME: normalization and escaping regions
2106 self.normalize_associated_types_in(span, &ty)
2110 fn set_tainted_by_errors(&self) {
2111 self.infcx.set_tainted_by_errors()
2114 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2115 self.write_ty(hir_id, ty)
2119 /// Controls whether the arguments are tupled. This is used for the call
2122 /// Tupling means that all call-side arguments are packed into a tuple and
2123 /// passed as a single parameter. For example, if tupling is enabled, this
2126 /// fn f(x: (isize, isize))
2128 /// Can be called as:
2135 #[derive(Clone, Eq, PartialEq)]
2136 enum TupleArgumentsFlag {
2141 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2143 inh: &'a Inherited<'a, 'tcx>,
2144 param_env: ty::ParamEnv<'tcx>,
2145 body_id: hir::HirId,
2146 ) -> FnCtxt<'a, 'tcx> {
2150 err_count_on_creation: inh.tcx.sess.err_count(),
2152 ret_coercion_span: RefCell::new(None),
2154 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2155 hir::CRATE_HIR_ID)),
2156 diverges: Cell::new(Diverges::Maybe),
2157 has_errors: Cell::new(false),
2158 enclosing_breakables: RefCell::new(EnclosingBreakables {
2160 by_id: Default::default(),
2166 pub fn sess(&self) -> &Session {
2170 pub fn errors_reported_since_creation(&self) -> bool {
2171 self.tcx.sess.err_count() > self.err_count_on_creation
2174 /// Produces warning on the given node, if the current point in the
2175 /// function is unreachable, and there hasn't been another warning.
2176 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2177 if self.diverges.get() == Diverges::Always &&
2178 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2179 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2180 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2181 !span.is_desugaring(DesugaringKind::CondTemporary) {
2182 self.diverges.set(Diverges::WarnedAlways);
2184 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2186 let msg = format!("unreachable {}", kind);
2187 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2193 code: ObligationCauseCode<'tcx>)
2194 -> ObligationCause<'tcx> {
2195 ObligationCause::new(span, self.body_id, code)
2198 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2199 self.cause(span, ObligationCauseCode::MiscObligation)
2202 /// Resolves type variables in `ty` if possible. Unlike the infcx
2203 /// version (resolve_vars_if_possible), this version will
2204 /// also select obligations if it seems useful, in an effort
2205 /// to get more type information.
2206 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2207 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2209 // No Infer()? Nothing needs doing.
2210 if !ty.has_infer_types() {
2211 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2215 // If `ty` is a type variable, see whether we already know what it is.
2216 ty = self.resolve_vars_if_possible(&ty);
2217 if !ty.has_infer_types() {
2218 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2222 // If not, try resolving pending obligations as much as
2223 // possible. This can help substantially when there are
2224 // indirect dependencies that don't seem worth tracking
2226 self.select_obligations_where_possible(false);
2227 ty = self.resolve_vars_if_possible(&ty);
2229 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2233 fn record_deferred_call_resolution(
2235 closure_def_id: DefId,
2236 r: DeferredCallResolution<'tcx>,
2238 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2239 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2242 fn remove_deferred_call_resolutions(
2244 closure_def_id: DefId,
2245 ) -> Vec<DeferredCallResolution<'tcx>> {
2246 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2247 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2250 pub fn tag(&self) -> String {
2251 format!("{:p}", self)
2254 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2255 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2256 span_bug!(span, "no type for local variable {}",
2257 self.tcx.hir().node_to_string(nid))
2262 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2263 debug!("write_ty({:?}, {:?}) in fcx {}",
2264 id, self.resolve_vars_if_possible(&ty), self.tag());
2265 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2267 if ty.references_error() {
2268 self.has_errors.set(true);
2269 self.set_tainted_by_errors();
2273 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2274 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2277 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2278 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2281 pub fn write_method_call(&self,
2283 method: MethodCallee<'tcx>) {
2284 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2285 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2286 self.write_substs(hir_id, method.substs);
2288 // When the method is confirmed, the `method.substs` includes
2289 // parameters from not just the method, but also the impl of
2290 // the method -- in particular, the `Self` type will be fully
2291 // resolved. However, those are not something that the "user
2292 // specified" -- i.e., those types come from the inferred type
2293 // of the receiver, not something the user wrote. So when we
2294 // create the user-substs, we want to replace those earlier
2295 // types with just the types that the user actually wrote --
2296 // that is, those that appear on the *method itself*.
2298 // As an example, if the user wrote something like
2299 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2300 // type of `foo` (possibly adjusted), but we don't want to
2301 // include that. We want just the `[_, u32]` part.
2302 if !method.substs.is_noop() {
2303 let method_generics = self.tcx.generics_of(method.def_id);
2304 if !method_generics.params.is_empty() {
2305 let user_type_annotation = self.infcx.probe(|_| {
2306 let user_substs = UserSubsts {
2307 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2308 let i = param.index as usize;
2309 if i < method_generics.parent_count {
2310 self.infcx.var_for_def(DUMMY_SP, param)
2315 user_self_ty: None, // not relevant here
2318 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2324 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2325 self.write_user_type_annotation(hir_id, user_type_annotation);
2330 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2331 if !substs.is_noop() {
2332 debug!("write_substs({:?}, {:?}) in fcx {}",
2337 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2341 /// Given the substs that we just converted from the HIR, try to
2342 /// canonicalize them and store them as user-given substitutions
2343 /// (i.e., substitutions that must be respected by the NLL check).
2345 /// This should be invoked **before any unifications have
2346 /// occurred**, so that annotations like `Vec<_>` are preserved
2348 pub fn write_user_type_annotation_from_substs(
2352 substs: SubstsRef<'tcx>,
2353 user_self_ty: Option<UserSelfTy<'tcx>>,
2356 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2357 user_self_ty={:?} in fcx {}",
2358 hir_id, def_id, substs, user_self_ty, self.tag(),
2361 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2362 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2363 &UserType::TypeOf(def_id, UserSubsts {
2368 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2369 self.write_user_type_annotation(hir_id, canonicalized);
2373 pub fn write_user_type_annotation(
2376 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2379 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2380 hir_id, canonical_user_type_annotation, self.tag(),
2383 if !canonical_user_type_annotation.is_identity() {
2384 self.tables.borrow_mut().user_provided_types_mut().insert(
2385 hir_id, canonical_user_type_annotation
2388 debug!("write_user_type_annotation: skipping identity substs");
2392 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2393 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2399 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2400 Entry::Vacant(entry) => { entry.insert(adj); },
2401 Entry::Occupied(mut entry) => {
2402 debug!(" - composing on top of {:?}", entry.get());
2403 match (&entry.get()[..], &adj[..]) {
2404 // Applying any adjustment on top of a NeverToAny
2405 // is a valid NeverToAny adjustment, because it can't
2407 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2409 Adjustment { kind: Adjust::Deref(_), .. },
2410 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2412 Adjustment { kind: Adjust::Deref(_), .. },
2413 .. // Any following adjustments are allowed.
2415 // A reborrow has no effect before a dereference.
2417 // FIXME: currently we never try to compose autoderefs
2418 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2420 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2421 expr, entry.get(), adj)
2423 *entry.get_mut() = adj;
2428 /// Basically whenever we are converting from a type scheme into
2429 /// the fn body space, we always want to normalize associated
2430 /// types as well. This function combines the two.
2431 fn instantiate_type_scheme<T>(&self,
2433 substs: SubstsRef<'tcx>,
2436 where T : TypeFoldable<'tcx>
2438 let value = value.subst(self.tcx, substs);
2439 let result = self.normalize_associated_types_in(span, &value);
2440 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2447 /// As `instantiate_type_scheme`, but for the bounds found in a
2448 /// generic type scheme.
2449 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2450 -> ty::InstantiatedPredicates<'tcx> {
2451 let bounds = self.tcx.predicates_of(def_id);
2452 let result = bounds.instantiate(self.tcx, substs);
2453 let result = self.normalize_associated_types_in(span, &result);
2454 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2461 /// Replaces the opaque types from the given value with type variables,
2462 /// and records the `OpaqueTypeMap` for later use during writeback. See
2463 /// `InferCtxt::instantiate_opaque_types` for more details.
2464 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2466 parent_id: hir::HirId,
2470 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2471 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2475 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2476 self.instantiate_opaque_types(
2485 let mut opaque_types = self.opaque_types.borrow_mut();
2486 for (ty, decl) in opaque_type_map {
2487 let old_value = opaque_types.insert(ty, decl);
2488 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2494 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2495 where T : TypeFoldable<'tcx>
2497 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2500 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2502 where T : TypeFoldable<'tcx>
2504 self.inh.partially_normalize_associated_types_in(span,
2510 pub fn require_type_meets(&self,
2513 code: traits::ObligationCauseCode<'tcx>,
2516 self.register_bound(
2519 traits::ObligationCause::new(span, self.body_id, code));
2522 pub fn require_type_is_sized(&self,
2525 code: traits::ObligationCauseCode<'tcx>)
2527 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2528 self.require_type_meets(ty, span, code, lang_item);
2531 pub fn require_type_is_sized_deferred(&self,
2534 code: traits::ObligationCauseCode<'tcx>)
2536 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2539 pub fn register_bound(&self,
2542 cause: traits::ObligationCause<'tcx>)
2544 self.fulfillment_cx.borrow_mut()
2545 .register_bound(self, self.param_env, ty, def_id, cause);
2548 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2549 let t = AstConv::ast_ty_to_ty(self, ast_t);
2550 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2554 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2555 let ty = self.to_ty(ast_ty);
2556 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2558 if Self::can_contain_user_lifetime_bounds(ty) {
2559 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2560 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2561 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2567 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2568 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2569 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2572 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2573 AstConv::ast_const_to_const(self, ast_c, ty)
2576 // If the type given by the user has free regions, save it for later, since
2577 // NLL would like to enforce those. Also pass in types that involve
2578 // projections, since those can resolve to `'static` bounds (modulo #54940,
2579 // which hopefully will be fixed by the time you see this comment, dear
2580 // reader, although I have my doubts). Also pass in types with inference
2581 // types, because they may be repeated. Other sorts of things are already
2582 // sufficiently enforced with erased regions. =)
2583 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2585 T: TypeFoldable<'tcx>
2587 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2590 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2591 match self.tables.borrow().node_types().get(id) {
2593 None if self.is_tainted_by_errors() => self.tcx.types.err,
2595 bug!("no type for node {}: {} in fcx {}",
2596 id, self.tcx.hir().node_to_string(id),
2602 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2603 /// outlive the region `r`.
2604 pub fn register_wf_obligation(&self,
2607 code: traits::ObligationCauseCode<'tcx>)
2609 // WF obligations never themselves fail, so no real need to give a detailed cause:
2610 let cause = traits::ObligationCause::new(span, self.body_id, code);
2611 self.register_predicate(traits::Obligation::new(cause,
2613 ty::Predicate::WellFormed(ty)));
2616 /// Registers obligations that all types appearing in `substs` are well-formed.
2617 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2618 for ty in substs.types() {
2619 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2623 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2624 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2625 /// trait/region obligations.
2627 /// For example, if there is a function:
2630 /// fn foo<'a,T:'a>(...)
2633 /// and a reference:
2639 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2640 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2641 pub fn add_obligations_for_parameters(&self,
2642 cause: traits::ObligationCause<'tcx>,
2643 predicates: &ty::InstantiatedPredicates<'tcx>)
2645 assert!(!predicates.has_escaping_bound_vars());
2647 debug!("add_obligations_for_parameters(predicates={:?})",
2650 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2651 self.register_predicate(obligation);
2655 // FIXME(arielb1): use this instead of field.ty everywhere
2656 // Only for fields! Returns <none> for methods>
2657 // Indifferent to privacy flags
2658 pub fn field_ty(&self,
2660 field: &'tcx ty::FieldDef,
2661 substs: SubstsRef<'tcx>)
2664 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2667 fn check_casts(&self) {
2668 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2669 for cast in deferred_cast_checks.drain(..) {
2674 fn resolve_generator_interiors(&self, def_id: DefId) {
2675 let mut generators = self.deferred_generator_interiors.borrow_mut();
2676 for (body_id, interior, kind) in generators.drain(..) {
2677 self.select_obligations_where_possible(false);
2678 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2682 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2683 // Non-numerics get replaced with ! or () (depending on whether
2684 // feature(never_type) is enabled, unconstrained ints with i32,
2685 // unconstrained floats with f64.
2686 // Fallback becomes very dubious if we have encountered type-checking errors.
2687 // In that case, fallback to Error.
2688 // The return value indicates whether fallback has occurred.
2689 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2690 use rustc::ty::error::UnconstrainedNumeric::Neither;
2691 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2693 assert!(ty.is_ty_infer());
2694 let fallback = match self.type_is_unconstrained_numeric(ty) {
2695 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2696 UnconstrainedInt => self.tcx.types.i32,
2697 UnconstrainedFloat => self.tcx.types.f64,
2698 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2699 Neither => return false,
2701 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2702 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2706 fn select_all_obligations_or_error(&self) {
2707 debug!("select_all_obligations_or_error");
2708 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2709 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2713 /// Select as many obligations as we can at present.
2714 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2715 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2716 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2720 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2721 /// returns a type of `&T`, but the actual type we assign to the
2722 /// *expression* is `T`. So this function just peels off the return
2723 /// type by one layer to yield `T`.
2724 fn make_overloaded_place_return_type(&self,
2725 method: MethodCallee<'tcx>)
2726 -> ty::TypeAndMut<'tcx>
2728 // extract method return type, which will be &T;
2729 let ret_ty = method.sig.output();
2731 // method returns &T, but the type as visible to user is T, so deref
2732 ret_ty.builtin_deref(true).unwrap()
2738 base_expr: &'tcx hir::Expr,
2742 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2743 // FIXME(#18741) -- this is almost but not quite the same as the
2744 // autoderef that normal method probing does. They could likely be
2747 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2748 let mut result = None;
2749 while result.is_none() && autoderef.next().is_some() {
2750 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2752 autoderef.finalize(self);
2756 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2757 /// (and otherwise adjust) `base_expr`, looking for a type which either
2758 /// supports builtin indexing or overloaded indexing.
2759 /// This loop implements one step in that search; the autoderef loop
2760 /// is implemented by `lookup_indexing`.
2764 base_expr: &hir::Expr,
2765 autoderef: &Autoderef<'a, 'tcx>,
2768 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2769 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2770 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2777 for &unsize in &[false, true] {
2778 let mut self_ty = adjusted_ty;
2780 // We only unsize arrays here.
2781 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2782 self_ty = self.tcx.mk_slice(element_ty);
2788 // If some lookup succeeds, write callee into table and extract index/element
2789 // type from the method signature.
2790 // If some lookup succeeded, install method in table
2791 let input_ty = self.next_ty_var(TypeVariableOrigin {
2792 kind: TypeVariableOriginKind::AutoDeref,
2793 span: base_expr.span,
2795 let method = self.try_overloaded_place_op(
2796 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2798 let result = method.map(|ok| {
2799 debug!("try_index_step: success, using overloaded indexing");
2800 let method = self.register_infer_ok_obligations(ok);
2802 let mut adjustments = autoderef.adjust_steps(self, needs);
2803 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2804 let mutbl = match r_mutbl {
2805 hir::MutImmutable => AutoBorrowMutability::Immutable,
2806 hir::MutMutable => AutoBorrowMutability::Mutable {
2807 // Indexing can be desugared to a method call,
2808 // so maybe we could use two-phase here.
2809 // See the documentation of AllowTwoPhase for why that's
2810 // not the case today.
2811 allow_two_phase_borrow: AllowTwoPhase::No,
2814 adjustments.push(Adjustment {
2815 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2816 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2823 adjustments.push(Adjustment {
2824 kind: Adjust::Pointer(PointerCast::Unsize),
2825 target: method.sig.inputs()[0]
2828 self.apply_adjustments(base_expr, adjustments);
2830 self.write_method_call(expr.hir_id, method);
2831 (input_ty, self.make_overloaded_place_return_type(method).ty)
2833 if result.is_some() {
2841 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2842 let (tr, name) = match (op, is_mut) {
2843 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2844 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2845 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2846 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2848 (tr, ast::Ident::with_empty_ctxt(name))
2851 fn try_overloaded_place_op(&self,
2854 arg_tys: &[Ty<'tcx>],
2857 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2859 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2865 // Try Mut first, if needed.
2866 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2867 let method = match (needs, mut_tr) {
2868 (Needs::MutPlace, Some(trait_did)) => {
2869 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2874 // Otherwise, fall back to the immutable version.
2875 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2876 let method = match (method, imm_tr) {
2877 (None, Some(trait_did)) => {
2878 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2880 (method, _) => method,
2886 fn check_method_argument_types(
2890 method: Result<MethodCallee<'tcx>, ()>,
2891 args_no_rcvr: &'tcx [hir::Expr],
2892 tuple_arguments: TupleArgumentsFlag,
2893 expected: Expectation<'tcx>,
2895 let has_error = match method {
2897 method.substs.references_error() || method.sig.references_error()
2902 let err_inputs = self.err_args(args_no_rcvr.len());
2904 let err_inputs = match tuple_arguments {
2905 DontTupleArguments => err_inputs,
2906 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2909 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2910 false, tuple_arguments, None);
2911 return self.tcx.types.err;
2914 let method = method.unwrap();
2915 // HACK(eddyb) ignore self in the definition (see above).
2916 let expected_arg_tys = self.expected_inputs_for_expected_output(
2919 method.sig.output(),
2920 &method.sig.inputs()[1..]
2922 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2923 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2924 self.tcx.hir().span_if_local(method.def_id));
2928 fn self_type_matches_expected_vid(
2930 trait_ref: ty::PolyTraitRef<'tcx>,
2931 expected_vid: ty::TyVid,
2933 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2935 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2936 trait_ref, self_ty, expected_vid
2939 ty::Infer(ty::TyVar(found_vid)) => {
2940 // FIXME: consider using `sub_root_var` here so we
2941 // can see through subtyping.
2942 let found_vid = self.root_var(found_vid);
2943 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2944 expected_vid == found_vid
2950 fn obligations_for_self_ty<'b>(
2953 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2956 // FIXME: consider using `sub_root_var` here so we
2957 // can see through subtyping.
2958 let ty_var_root = self.root_var(self_ty);
2959 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2960 self_ty, ty_var_root,
2961 self.fulfillment_cx.borrow().pending_obligations());
2965 .pending_obligations()
2967 .filter_map(move |obligation| match obligation.predicate {
2968 ty::Predicate::Projection(ref data) =>
2969 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2970 ty::Predicate::Trait(ref data) =>
2971 Some((data.to_poly_trait_ref(), obligation)),
2972 ty::Predicate::Subtype(..) => None,
2973 ty::Predicate::RegionOutlives(..) => None,
2974 ty::Predicate::TypeOutlives(..) => None,
2975 ty::Predicate::WellFormed(..) => None,
2976 ty::Predicate::ObjectSafe(..) => None,
2977 ty::Predicate::ConstEvaluatable(..) => None,
2978 // N.B., this predicate is created by breaking down a
2979 // `ClosureType: FnFoo()` predicate, where
2980 // `ClosureType` represents some `Closure`. It can't
2981 // possibly be referring to the current closure,
2982 // because we haven't produced the `Closure` for
2983 // this closure yet; this is exactly why the other
2984 // code is looking for a self type of a unresolved
2985 // inference variable.
2986 ty::Predicate::ClosureKind(..) => None,
2987 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2990 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2991 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2992 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2996 /// Generic function that factors out common logic from function calls,
2997 /// method calls and overloaded operators.
2998 fn check_argument_types(
3002 fn_inputs: &[Ty<'tcx>],
3003 expected_arg_tys: &[Ty<'tcx>],
3004 args: &'tcx [hir::Expr],
3006 tuple_arguments: TupleArgumentsFlag,
3007 def_span: Option<Span>,
3011 // Grab the argument types, supplying fresh type variables
3012 // if the wrong number of arguments were supplied
3013 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3019 // All the input types from the fn signature must outlive the call
3020 // so as to validate implied bounds.
3021 for &fn_input_ty in fn_inputs {
3022 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3025 let expected_arg_count = fn_inputs.len();
3027 let param_count_error = |expected_count: usize,
3032 let mut err = tcx.sess.struct_span_err_with_code(sp,
3033 &format!("this function takes {}{} but {} {} supplied",
3034 if c_variadic { "at least " } else { "" },
3035 potentially_plural_count(expected_count, "parameter"),
3036 potentially_plural_count(arg_count, "parameter"),
3037 if arg_count == 1 {"was"} else {"were"}),
3038 DiagnosticId::Error(error_code.to_owned()));
3040 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3041 err.span_label(def_s, "defined here");
3044 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3045 // remove closing `)` from the span
3046 let sugg_span = sugg_span.shrink_to_lo();
3047 err.span_suggestion(
3049 "expected the unit value `()`; create it with empty parentheses",
3051 Applicability::MachineApplicable);
3053 err.span_label(sp, format!("expected {}{}",
3054 if c_variadic { "at least " } else { "" },
3055 potentially_plural_count(expected_count, "parameter")));
3060 let mut expected_arg_tys = expected_arg_tys.to_vec();
3062 let formal_tys = if tuple_arguments == TupleArguments {
3063 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3064 match tuple_type.sty {
3065 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3066 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3067 expected_arg_tys = vec![];
3068 self.err_args(args.len())
3070 ty::Tuple(arg_types) => {
3071 expected_arg_tys = match expected_arg_tys.get(0) {
3072 Some(&ty) => match ty.sty {
3073 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3078 arg_types.iter().map(|k| k.expect_ty()).collect()
3081 span_err!(tcx.sess, sp, E0059,
3082 "cannot use call notation; the first type parameter \
3083 for the function trait is neither a tuple nor unit");
3084 expected_arg_tys = vec![];
3085 self.err_args(args.len())
3088 } else if expected_arg_count == supplied_arg_count {
3090 } else if c_variadic {
3091 if supplied_arg_count >= expected_arg_count {
3094 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3095 expected_arg_tys = vec![];
3096 self.err_args(supplied_arg_count)
3099 // is the missing argument of type `()`?
3100 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3101 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3102 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3103 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3107 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3109 expected_arg_tys = vec![];
3110 self.err_args(supplied_arg_count)
3113 debug!("check_argument_types: formal_tys={:?}",
3114 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3116 // If there is no expectation, expect formal_tys.
3117 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3123 // Check the arguments.
3124 // We do this in a pretty awful way: first we type-check any arguments
3125 // that are not closures, then we type-check the closures. This is so
3126 // that we have more information about the types of arguments when we
3127 // type-check the functions. This isn't really the right way to do this.
3128 for &check_closures in &[false, true] {
3129 debug!("check_closures={}", check_closures);
3131 // More awful hacks: before we check argument types, try to do
3132 // an "opportunistic" vtable resolution of any trait bounds on
3133 // the call. This helps coercions.
3135 self.select_obligations_where_possible(false);
3138 // For C-variadic functions, we don't have a declared type for all of
3139 // the arguments hence we only do our usual type checking with
3140 // the arguments who's types we do know.
3141 let t = if c_variadic {
3143 } else if tuple_arguments == TupleArguments {
3148 for (i, arg) in args.iter().take(t).enumerate() {
3149 // Warn only for the first loop (the "no closures" one).
3150 // Closure arguments themselves can't be diverging, but
3151 // a previous argument can, e.g., `foo(panic!(), || {})`.
3152 if !check_closures {
3153 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3156 let is_closure = match arg.node {
3157 ExprKind::Closure(..) => true,
3161 if is_closure != check_closures {
3165 debug!("checking the argument");
3166 let formal_ty = formal_tys[i];
3168 // The special-cased logic below has three functions:
3169 // 1. Provide as good of an expected type as possible.
3170 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3172 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3174 // 2. Coerce to the most detailed type that could be coerced
3175 // to, which is `expected_ty` if `rvalue_hint` returns an
3176 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3177 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3178 // We're processing function arguments so we definitely want to use
3179 // two-phase borrows.
3180 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3182 // 3. Relate the expected type and the formal one,
3183 // if the expected type was used for the coercion.
3184 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3188 // We also need to make sure we at least write the ty of the other
3189 // arguments which we skipped above.
3191 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3192 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3193 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3196 for arg in args.iter().skip(expected_arg_count) {
3197 let arg_ty = self.check_expr(&arg);
3199 // There are a few types which get autopromoted when passed via varargs
3200 // in C but we just error out instead and require explicit casts.
3201 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3203 ty::Float(ast::FloatTy::F32) => {
3204 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3206 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3207 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3209 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3210 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3213 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3214 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3215 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3223 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3224 vec![self.tcx.types.err; len]
3227 // AST fragment checking
3230 expected: Expectation<'tcx>)
3236 ast::LitKind::Str(..) => tcx.mk_static_str(),
3237 ast::LitKind::ByteStr(ref v) => {
3238 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3239 tcx.mk_array(tcx.types.u8, v.len() as u64))
3241 ast::LitKind::Byte(_) => tcx.types.u8,
3242 ast::LitKind::Char(_) => tcx.types.char,
3243 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3244 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3245 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3246 let opt_ty = expected.to_option(self).and_then(|ty| {
3248 ty::Int(_) | ty::Uint(_) => Some(ty),
3249 ty::Char => Some(tcx.types.u8),
3250 ty::RawPtr(..) => Some(tcx.types.usize),
3251 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3255 opt_ty.unwrap_or_else(|| self.next_int_var())
3257 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3258 ast::LitKind::FloatUnsuffixed(_) => {
3259 let opt_ty = expected.to_option(self).and_then(|ty| {
3261 ty::Float(_) => Some(ty),
3265 opt_ty.unwrap_or_else(|| self.next_float_var())
3267 ast::LitKind::Bool(_) => tcx.types.bool,
3268 ast::LitKind::Err(_) => tcx.types.err,
3272 // Determine the `Self` type, using fresh variables for all variables
3273 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3274 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3276 pub fn impl_self_ty(&self,
3277 span: Span, // (potential) receiver for this impl
3279 -> TypeAndSubsts<'tcx> {
3280 let ity = self.tcx.type_of(did);
3281 debug!("impl_self_ty: ity={:?}", ity);
3283 let substs = self.fresh_substs_for_item(span, did);
3284 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3286 TypeAndSubsts { substs: substs, ty: substd_ty }
3289 /// Unifies the output type with the expected type early, for more coercions
3290 /// and forward type information on the input expressions.
3291 fn expected_inputs_for_expected_output(&self,
3293 expected_ret: Expectation<'tcx>,
3294 formal_ret: Ty<'tcx>,
3295 formal_args: &[Ty<'tcx>])
3297 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3298 let ret_ty = match expected_ret.only_has_type(self) {
3300 None => return Vec::new()
3302 let expect_args = self.fudge_inference_if_ok(|| {
3303 // Attempt to apply a subtyping relationship between the formal
3304 // return type (likely containing type variables if the function
3305 // is polymorphic) and the expected return type.
3306 // No argument expectations are produced if unification fails.
3307 let origin = self.misc(call_span);
3308 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3310 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3311 // to identity so the resulting type is not constrained.
3314 // Process any obligations locally as much as
3315 // we can. We don't care if some things turn
3316 // out unconstrained or ambiguous, as we're
3317 // just trying to get hints here.
3318 self.save_and_restore_in_snapshot_flag(|_| {
3319 let mut fulfill = TraitEngine::new(self.tcx);
3320 for obligation in ok.obligations {
3321 fulfill.register_predicate_obligation(self, obligation);
3323 fulfill.select_where_possible(self)
3324 }).map_err(|_| ())?;
3326 Err(_) => return Err(()),
3329 // Record all the argument types, with the substitutions
3330 // produced from the above subtyping unification.
3331 Ok(formal_args.iter().map(|ty| {
3332 self.resolve_vars_if_possible(ty)
3334 }).unwrap_or_default();
3335 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3336 formal_args, formal_ret,
3337 expect_args, expected_ret);
3341 pub fn check_struct_path(&self,
3344 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3345 let path_span = match *qpath {
3346 QPath::Resolved(_, ref path) => path.span,
3347 QPath::TypeRelative(ref qself, _) => qself.span
3349 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3350 let variant = match def {
3352 self.set_tainted_by_errors();
3355 Res::Def(DefKind::Variant, _) => {
3357 ty::Adt(adt, substs) => {
3358 Some((adt.variant_of_res(def), adt.did, substs))
3360 _ => bug!("unexpected type: {:?}", ty)
3363 Res::Def(DefKind::Struct, _)
3364 | Res::Def(DefKind::Union, _)
3365 | Res::Def(DefKind::TyAlias, _)
3366 | Res::Def(DefKind::AssocTy, _)
3367 | Res::SelfTy(..) => {
3369 ty::Adt(adt, substs) if !adt.is_enum() => {
3370 Some((adt.non_enum_variant(), adt.did, substs))
3375 _ => bug!("unexpected definition: {:?}", def)
3378 if let Some((variant, did, substs)) = variant {
3379 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3380 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3382 // Check bounds on type arguments used in the path.
3383 let bounds = self.instantiate_bounds(path_span, did, substs);
3384 let cause = traits::ObligationCause::new(path_span, self.body_id,
3385 traits::ItemObligation(did));
3386 self.add_obligations_for_parameters(cause, &bounds);
3390 struct_span_err!(self.tcx.sess, path_span, E0071,
3391 "expected struct, variant or union type, found {}",
3392 ty.sort_string(self.tcx))
3393 .span_label(path_span, "not a struct")
3399 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3400 // The newly resolved definition is written into `type_dependent_defs`.
3401 fn finish_resolving_struct_path(&self,
3408 QPath::Resolved(ref maybe_qself, ref path) => {
3409 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3410 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3413 QPath::TypeRelative(ref qself, ref segment) => {
3414 let ty = self.to_ty(qself);
3416 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3421 let result = AstConv::associated_path_to_ty(
3430 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3431 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3433 // Write back the new resolution.
3434 self.write_resolution(hir_id, result);
3436 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3441 /// Resolves an associated value path into a base type and associated constant, or method
3442 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3443 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3447 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3449 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3450 let (ty, qself, item_segment) = match *qpath {
3451 QPath::Resolved(ref opt_qself, ref path) => {
3453 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3454 &path.segments[..]);
3456 QPath::TypeRelative(ref qself, ref segment) => {
3457 (self.to_ty(qself), qself, segment)
3460 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3461 // Return directly on cache hit. This is useful to avoid doubly reporting
3462 // errors with default match binding modes. See #44614.
3463 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3464 .unwrap_or(Res::Err);
3465 return (def, Some(ty), slice::from_ref(&**item_segment));
3467 let item_name = item_segment.ident;
3468 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3469 let result = match error {
3470 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3471 _ => Err(ErrorReported),
3473 if item_name.name != kw::Invalid {
3474 self.report_method_error(
3478 SelfSource::QPath(qself),
3486 // Write back the new resolution.
3487 self.write_resolution(hir_id, result);
3489 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3491 slice::from_ref(&**item_segment),
3495 pub fn check_decl_initializer(
3497 local: &'tcx hir::Local,
3498 init: &'tcx hir::Expr,
3500 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3501 // for #42640 (default match binding modes).
3504 let ref_bindings = local.pat.contains_explicit_ref_binding();
3506 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3507 if let Some(m) = ref_bindings {
3508 // Somewhat subtle: if we have a `ref` binding in the pattern,
3509 // we want to avoid introducing coercions for the RHS. This is
3510 // both because it helps preserve sanity and, in the case of
3511 // ref mut, for soundness (issue #23116). In particular, in
3512 // the latter case, we need to be clear that the type of the
3513 // referent for the reference that results is *equal to* the
3514 // type of the place it is referencing, and not some
3515 // supertype thereof.
3516 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3517 self.demand_eqtype(init.span, local_ty, init_ty);
3520 self.check_expr_coercable_to_type(init, local_ty)
3524 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3525 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3526 self.write_ty(local.hir_id, t);
3528 if let Some(ref init) = local.init {
3529 let init_ty = self.check_decl_initializer(local, &init);
3530 if init_ty.references_error() {
3531 self.write_ty(local.hir_id, init_ty);
3535 self.check_pat_walk(
3538 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3541 let pat_ty = self.node_ty(local.pat.hir_id);
3542 if pat_ty.references_error() {
3543 self.write_ty(local.hir_id, pat_ty);
3547 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3548 // Don't do all the complex logic below for `DeclItem`.
3550 hir::StmtKind::Item(..) => return,
3551 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3554 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3556 // Hide the outer diverging and `has_errors` flags.
3557 let old_diverges = self.diverges.get();
3558 let old_has_errors = self.has_errors.get();
3559 self.diverges.set(Diverges::Maybe);
3560 self.has_errors.set(false);
3563 hir::StmtKind::Local(ref l) => {
3564 self.check_decl_local(&l);
3567 hir::StmtKind::Item(_) => {}
3568 hir::StmtKind::Expr(ref expr) => {
3569 // Check with expected type of `()`.
3570 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3572 hir::StmtKind::Semi(ref expr) => {
3573 self.check_expr(&expr);
3577 // Combine the diverging and `has_error` flags.
3578 self.diverges.set(self.diverges.get() | old_diverges);
3579 self.has_errors.set(self.has_errors.get() | old_has_errors);
3582 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3583 let unit = self.tcx.mk_unit();
3584 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3586 // if the block produces a `!` value, that can always be
3587 // (effectively) coerced to unit.
3589 self.demand_suptype(blk.span, unit, ty);
3593 fn check_block_with_expected(
3595 blk: &'tcx hir::Block,
3596 expected: Expectation<'tcx>,
3599 let mut fcx_ps = self.ps.borrow_mut();
3600 let unsafety_state = fcx_ps.recurse(blk);
3601 replace(&mut *fcx_ps, unsafety_state)
3604 // In some cases, blocks have just one exit, but other blocks
3605 // can be targeted by multiple breaks. This can happen both
3606 // with labeled blocks as well as when we desugar
3607 // a `try { ... }` expression.
3611 // 'a: { if true { break 'a Err(()); } Ok(()) }
3613 // Here we would wind up with two coercions, one from
3614 // `Err(())` and the other from the tail expression
3615 // `Ok(())`. If the tail expression is omitted, that's a
3616 // "forced unit" -- unless the block diverges, in which
3617 // case we can ignore the tail expression (e.g., `'a: {
3618 // break 'a 22; }` would not force the type of the block
3620 let tail_expr = blk.expr.as_ref();
3621 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3622 let coerce = if blk.targeted_by_break {
3623 CoerceMany::new(coerce_to_ty)
3625 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3626 Some(e) => slice::from_ref(e),
3629 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3632 let prev_diverges = self.diverges.get();
3633 let ctxt = BreakableCtxt {
3634 coerce: Some(coerce),
3638 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3639 for s in &blk.stmts {
3643 // check the tail expression **without** holding the
3644 // `enclosing_breakables` lock below.
3645 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3647 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3648 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3649 let coerce = ctxt.coerce.as_mut().unwrap();
3650 if let Some(tail_expr_ty) = tail_expr_ty {
3651 let tail_expr = tail_expr.unwrap();
3652 let cause = self.cause(tail_expr.span,
3653 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3659 // Subtle: if there is no explicit tail expression,
3660 // that is typically equivalent to a tail expression
3661 // of `()` -- except if the block diverges. In that
3662 // case, there is no value supplied from the tail
3663 // expression (assuming there are no other breaks,
3664 // this implies that the type of the block will be
3667 // #41425 -- label the implicit `()` as being the
3668 // "found type" here, rather than the "expected type".
3669 if !self.diverges.get().always() {
3670 // #50009 -- Do not point at the entire fn block span, point at the return type
3671 // span, as it is the cause of the requirement, and
3672 // `consider_hint_about_removing_semicolon` will point at the last expression
3673 // if it were a relevant part of the error. This improves usability in editors
3674 // that highlight errors inline.
3675 let mut sp = blk.span;
3676 let mut fn_span = None;
3677 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3678 let ret_sp = decl.output.span();
3679 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3680 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3681 // output would otherwise be incorrect and even misleading. Make sure
3682 // the span we're aiming at correspond to a `fn` body.
3683 if block_sp == blk.span {
3685 fn_span = Some(ident.span);
3689 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3690 if let Some(expected_ty) = expected.only_has_type(self) {
3691 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3693 if let Some(fn_span) = fn_span {
3694 err.span_label(fn_span, "this function's body doesn't return");
3702 // If we can break from the block, then the block's exit is always reachable
3703 // (... as long as the entry is reachable) - regardless of the tail of the block.
3704 self.diverges.set(prev_diverges);
3707 let mut ty = ctxt.coerce.unwrap().complete(self);
3709 if self.has_errors.get() || ty.references_error() {
3710 ty = self.tcx.types.err
3713 self.write_ty(blk.hir_id, ty);
3715 *self.ps.borrow_mut() = prev;
3719 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3720 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3722 Node::Item(&hir::Item {
3723 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3725 Node::ImplItem(&hir::ImplItem {
3726 node: hir::ImplItemKind::Method(_, body_id), ..
3728 let body = self.tcx.hir().body(body_id);
3729 if let ExprKind::Block(block, _) = &body.value.node {
3730 return Some(block.span);
3738 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3739 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3740 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3741 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3744 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3745 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3747 Node::Item(&hir::Item {
3748 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3750 // This is less than ideal, it will not suggest a return type span on any
3751 // method called `main`, regardless of whether it is actually the entry point,
3752 // but it will still present it as the reason for the expected type.
3753 Some((decl, ident, ident.name != sym::main))
3755 Node::TraitItem(&hir::TraitItem {
3756 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3759 }) => Some((decl, ident, true)),
3760 Node::ImplItem(&hir::ImplItem {
3761 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3764 }) => Some((decl, ident, false)),
3769 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3770 /// suggestion can be made, `None` otherwise.
3771 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3772 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3773 // `while` before reaching it, as block tail returns are not available in them.
3774 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3775 let parent = self.tcx.hir().get(blk_id);
3776 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3780 /// On implicit return expressions with mismatched types, provides the following suggestions:
3782 /// - Points out the method's return type as the reason for the expected type.
3783 /// - Possible missing semicolon.
3784 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3785 pub fn suggest_mismatched_types_on_tail(
3787 err: &mut DiagnosticBuilder<'tcx>,
3788 expression: &'tcx hir::Expr,
3794 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3795 let mut pointing_at_return_type = false;
3796 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3797 pointing_at_return_type = self.suggest_missing_return_type(
3798 err, &fn_decl, expected, found, can_suggest);
3800 self.suggest_ref_or_into(err, expression, expected, found);
3801 pointing_at_return_type
3804 pub fn suggest_ref_or_into(
3806 err: &mut DiagnosticBuilder<'tcx>,
3811 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3812 err.span_suggestion(
3816 Applicability::MachineApplicable,
3818 } else if !self.check_for_cast(err, expr, found, expected) {
3819 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3823 let methods = self.get_conversion_methods(expr.span, expected, found);
3824 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3825 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3826 .filter_map(|(receiver, method)| {
3827 let method_call = format!(".{}()", method.ident);
3828 if receiver.ends_with(&method_call) {
3829 None // do not suggest code that is already there (#53348)
3831 let method_call_list = [".to_vec()", ".to_string()"];
3832 let sugg = if receiver.ends_with(".clone()")
3833 && method_call_list.contains(&method_call.as_str()) {
3834 let max_len = receiver.rfind(".").unwrap();
3835 format!("{}{}", &receiver[..max_len], method_call)
3837 format!("{}{}", receiver, method_call)
3839 Some(if is_struct_pat_shorthand_field {
3840 format!("{}: {}", receiver, sugg)
3846 if suggestions.peek().is_some() {
3847 err.span_suggestions(
3849 "try using a conversion method",
3851 Applicability::MaybeIncorrect,
3858 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3862 /// bar_that_returns_u32()
3866 /// This routine checks if the return expression in a block would make sense on its own as a
3867 /// statement and the return type has been left as default or has been specified as `()`. If so,
3868 /// it suggests adding a semicolon.
3869 fn suggest_missing_semicolon(
3871 err: &mut DiagnosticBuilder<'tcx>,
3872 expression: &'tcx hir::Expr,
3876 if expected.is_unit() {
3877 // `BlockTailExpression` only relevant if the tail expr would be
3878 // useful on its own.
3879 match expression.node {
3880 ExprKind::Call(..) |
3881 ExprKind::MethodCall(..) |
3882 ExprKind::Loop(..) |
3883 ExprKind::Match(..) |
3884 ExprKind::Block(..) => {
3885 let sp = self.tcx.sess.source_map().next_point(cause_span);
3886 err.span_suggestion(
3888 "try adding a semicolon",
3890 Applicability::MachineApplicable);
3897 /// A possible error is to forget to add a return type that is needed:
3901 /// bar_that_returns_u32()
3905 /// This routine checks if the return type is left as default, the method is not part of an
3906 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3908 fn suggest_missing_return_type(
3910 err: &mut DiagnosticBuilder<'tcx>,
3911 fn_decl: &hir::FnDecl,
3916 // Only suggest changing the return type for methods that
3917 // haven't set a return type at all (and aren't `fn main()` or an impl).
3918 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3919 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3920 err.span_suggestion(
3922 "try adding a return type",
3923 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3924 Applicability::MachineApplicable);
3927 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3928 err.span_label(span, "possibly return type missing here?");
3931 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3932 // `fn main()` must return `()`, do not suggest changing return type
3933 err.span_label(span, "expected `()` because of default return type");
3936 // expectation was caused by something else, not the default return
3937 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3938 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3939 // Only point to return type if the expected type is the return type, as if they
3940 // are not, the expectation must have been caused by something else.
3941 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3943 let ty = AstConv::ast_ty_to_ty(self, ty);
3944 debug!("suggest_missing_return_type: return type {:?}", ty);
3945 debug!("suggest_missing_return_type: expected type {:?}", ty);
3946 if ty.sty == expected.sty {
3947 err.span_label(sp, format!("expected `{}` because of return type",
3956 /// A possible error is to forget to add `.await` when using futures:
3959 /// #![feature(async_await)]
3961 /// async fn make_u32() -> u32 {
3965 /// fn take_u32(x: u32) {}
3967 /// async fn foo() {
3968 /// let x = make_u32();
3973 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3974 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3975 /// `.await` to the tail of the expression.
3976 fn suggest_missing_await(
3978 err: &mut DiagnosticBuilder<'tcx>,
3983 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3984 // body isn't `async`.
3985 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3986 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3987 let body = self.tcx().hir().body(body_id);
3988 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3990 // Check for `Future` implementations by constructing a predicate to
3991 // prove: `<T as Future>::Output == U`
3992 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3993 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3994 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3995 // `<T as Future>::Output`
3996 projection_ty: ty::ProjectionTy {
3998 substs: self.tcx.mk_substs_trait(
4000 self.fresh_substs_for_item(sp, item_def_id)
4007 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
4008 if self.infcx.predicate_may_hold(&obligation) {
4009 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
4010 err.span_suggestion(
4012 "consider using `.await` here",
4013 format!("{}.await", code),
4014 Applicability::MaybeIncorrect,
4022 /// A common error is to add an extra semicolon:
4025 /// fn foo() -> usize {
4030 /// This routine checks if the final statement in a block is an
4031 /// expression with an explicit semicolon whose type is compatible
4032 /// with `expected_ty`. If so, it suggests removing the semicolon.
4033 fn consider_hint_about_removing_semicolon(
4035 blk: &'tcx hir::Block,
4036 expected_ty: Ty<'tcx>,
4037 err: &mut DiagnosticBuilder<'_>,
4039 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4040 err.span_suggestion(
4042 "consider removing this semicolon",
4044 Applicability::MachineApplicable,
4049 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4050 // Be helpful when the user wrote `{... expr;}` and
4051 // taking the `;` off is enough to fix the error.
4052 let last_stmt = blk.stmts.last()?;
4053 let last_expr = match last_stmt.node {
4054 hir::StmtKind::Semi(ref e) => e,
4057 let last_expr_ty = self.node_ty(last_expr.hir_id);
4058 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4061 let original_span = original_sp(last_stmt.span, blk.span);
4062 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4065 // Instantiates the given path, which must refer to an item with the given
4066 // number of type parameters and type.
4067 pub fn instantiate_value_path(&self,
4068 segments: &[hir::PathSegment],
4069 self_ty: Option<Ty<'tcx>>,
4073 -> (Ty<'tcx>, Res) {
4075 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4084 let path_segs = match res {
4085 Res::Local(_) | Res::SelfCtor(_) => vec![],
4086 Res::Def(kind, def_id) =>
4087 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4088 _ => bug!("instantiate_value_path on {:?}", res),
4091 let mut user_self_ty = None;
4092 let mut is_alias_variant_ctor = false;
4094 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4095 if let Some(self_ty) = self_ty {
4096 let adt_def = self_ty.ty_adt_def().unwrap();
4097 user_self_ty = Some(UserSelfTy {
4098 impl_def_id: adt_def.did,
4101 is_alias_variant_ctor = true;
4104 Res::Def(DefKind::Method, def_id)
4105 | Res::Def(DefKind::AssocConst, def_id) => {
4106 let container = tcx.associated_item(def_id).container;
4107 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4109 ty::TraitContainer(trait_did) => {
4110 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4112 ty::ImplContainer(impl_def_id) => {
4113 if segments.len() == 1 {
4114 // `<T>::assoc` will end up here, and so
4115 // can `T::assoc`. It this came from an
4116 // inherent impl, we need to record the
4117 // `T` for posterity (see `UserSelfTy` for
4119 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4120 user_self_ty = Some(UserSelfTy {
4131 // Now that we have categorized what space the parameters for each
4132 // segment belong to, let's sort out the parameters that the user
4133 // provided (if any) into their appropriate spaces. We'll also report
4134 // errors if type parameters are provided in an inappropriate place.
4136 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4137 let generics_has_err = AstConv::prohibit_generics(
4138 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4139 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4146 if let Res::Local(hid) = res {
4147 let ty = self.local_ty(span, hid).decl_ty;
4148 let ty = self.normalize_associated_types_in(span, &ty);
4149 self.write_ty(hir_id, ty);
4153 if generics_has_err {
4154 // Don't try to infer type parameters when prohibited generic arguments were given.
4155 user_self_ty = None;
4158 // Now we have to compare the types that the user *actually*
4159 // provided against the types that were *expected*. If the user
4160 // did not provide any types, then we want to substitute inference
4161 // variables. If the user provided some types, we may still need
4162 // to add defaults. If the user provided *too many* types, that's
4165 let mut infer_args_for_err = FxHashSet::default();
4166 for &PathSeg(def_id, index) in &path_segs {
4167 let seg = &segments[index];
4168 let generics = tcx.generics_of(def_id);
4169 // Argument-position `impl Trait` is treated as a normal generic
4170 // parameter internally, but we don't allow users to specify the
4171 // parameter's value explicitly, so we have to do some error-
4173 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4178 false, // `is_method_call`
4180 if suppress_errors {
4181 infer_args_for_err.insert(index);
4182 self.set_tainted_by_errors(); // See issue #53251.
4186 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4187 tcx.generics_of(*def_id).has_self
4188 }).unwrap_or(false);
4190 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4191 let ty = self.impl_self_ty(span, impl_def_id).ty;
4192 let adt_def = ty.ty_adt_def();
4195 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4196 let variant = adt_def.non_enum_variant();
4197 let ctor_def_id = variant.ctor_def_id.unwrap();
4199 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4204 let mut err = tcx.sess.struct_span_err(span,
4205 "the `Self` constructor can only be used with tuple or unit structs");
4206 if let Some(adt_def) = adt_def {
4207 match adt_def.adt_kind() {
4209 err.help("did you mean to use one of the enum's variants?");
4213 err.span_suggestion(
4215 "use curly brackets",
4216 String::from("Self { /* fields */ }"),
4217 Applicability::HasPlaceholders,
4224 return (tcx.types.err, res)
4230 let def_id = res.def_id();
4232 // The things we are substituting into the type should not contain
4233 // escaping late-bound regions, and nor should the base type scheme.
4234 let ty = tcx.type_of(def_id);
4236 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4242 // Provide the generic args, and whether types should be inferred.
4244 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4247 // If we've encountered an `impl Trait`-related error, we're just
4248 // going to infer the arguments for better error messages.
4249 if !infer_args_for_err.contains(&index) {
4250 // Check whether the user has provided generic arguments.
4251 if let Some(ref data) = segments[index].args {
4252 return (Some(data), segments[index].infer_args);
4255 return (None, segments[index].infer_args);
4260 // Provide substitutions for parameters for which (valid) arguments have been provided.
4262 match (¶m.kind, arg) {
4263 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4264 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4266 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4267 self.to_ty(ty).into()
4269 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4270 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4272 _ => unreachable!(),
4275 // Provide substitutions for parameters for which arguments are inferred.
4276 |substs, param, infer_args| {
4278 GenericParamDefKind::Lifetime => {
4279 self.re_infer(Some(param), span).unwrap().into()
4281 GenericParamDefKind::Type { has_default, .. } => {
4282 if !infer_args && has_default {
4283 // If we have a default, then we it doesn't matter that we're not
4284 // inferring the type arguments: we provide the default where any
4286 let default = tcx.type_of(param.def_id);
4289 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4292 // If no type arguments were provided, we have to infer them.
4293 // This case also occurs as a result of some malformed input, e.g.
4294 // a lifetime argument being given instead of a type parameter.
4295 // Using inference instead of `Error` gives better error messages.
4296 self.var_for_def(span, param)
4299 GenericParamDefKind::Const => {
4300 // FIXME(const_generics:defaults)
4301 // No const parameters were provided, we have to infer them.
4302 self.var_for_def(span, param)
4307 assert!(!substs.has_escaping_bound_vars());
4308 assert!(!ty.has_escaping_bound_vars());
4310 // First, store the "user substs" for later.
4311 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4313 // Add all the obligations that are required, substituting and
4314 // normalized appropriately.
4315 let bounds = self.instantiate_bounds(span, def_id, &substs);
4316 self.add_obligations_for_parameters(
4317 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4320 // Substitute the values for the type parameters into the type of
4321 // the referenced item.
4322 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4324 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4325 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4326 // is inherent, there is no `Self` parameter; instead, the impl needs
4327 // type parameters, which we can infer by unifying the provided `Self`
4328 // with the substituted impl type.
4329 // This also occurs for an enum variant on a type alias.
4330 let ty = tcx.type_of(impl_def_id);
4332 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4333 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4334 Ok(ok) => self.register_infer_ok_obligations(ok),
4336 self.tcx.sess.delay_span_bug(span, &format!(
4337 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4345 self.check_rustc_args_require_const(def_id, hir_id, span);
4347 debug!("instantiate_value_path: type of {:?} is {:?}",
4350 self.write_substs(hir_id, substs);
4352 (ty_substituted, res)
4355 fn check_rustc_args_require_const(&self,
4359 // We're only interested in functions tagged with
4360 // #[rustc_args_required_const], so ignore anything that's not.
4361 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4365 // If our calling expression is indeed the function itself, we're good!
4366 // If not, generate an error that this can only be called directly.
4367 if let Node::Expr(expr) = self.tcx.hir().get(
4368 self.tcx.hir().get_parent_node(hir_id))
4370 if let ExprKind::Call(ref callee, ..) = expr.node {
4371 if callee.hir_id == hir_id {
4377 self.tcx.sess.span_err(span, "this function can only be invoked \
4378 directly, not through a function pointer");
4381 // Resolves `typ` by a single level if `typ` is a type variable.
4382 // If no resolution is possible, then an error is reported.
4383 // Numeric inference variables may be left unresolved.
4384 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4385 let ty = self.resolve_type_vars_with_obligations(ty);
4386 if !ty.is_ty_var() {
4389 if !self.is_tainted_by_errors() {
4390 self.need_type_info_err((**self).body_id, sp, ty)
4391 .note("type must be known at this point")
4394 self.demand_suptype(sp, self.tcx.types.err, ty);
4399 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4402 ctxt: BreakableCtxt<'tcx>,
4404 ) -> (BreakableCtxt<'tcx>, R) {
4407 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4408 index = enclosing_breakables.stack.len();
4409 enclosing_breakables.by_id.insert(id, index);
4410 enclosing_breakables.stack.push(ctxt);
4414 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4415 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4416 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4417 enclosing_breakables.stack.pop().expect("missing breakable context")
4422 /// Instantiate a QueryResponse in a probe context, without a
4423 /// good ObligationCause.
4424 fn probe_instantiate_query_response(
4427 original_values: &OriginalQueryValues<'tcx>,
4428 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4429 ) -> InferResult<'tcx, Ty<'tcx>>
4431 self.instantiate_query_response_and_region_obligations(
4432 &traits::ObligationCause::misc(span, self.body_id),
4438 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4439 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4440 let mut contained_in_place = false;
4442 while let hir::Node::Expr(parent_expr) =
4443 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4445 match &parent_expr.node {
4446 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4447 if lhs.hir_id == expr_id {
4448 contained_in_place = true;
4454 expr_id = parent_expr.hir_id;
4461 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4462 let own_counts = generics.own_counts();
4464 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4470 if own_counts.types == 0 {
4474 // Make a vector of booleans initially `false`; set to `true` when used.
4475 let mut types_used = vec![false; own_counts.types];
4477 for leaf_ty in ty.walk() {
4478 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4479 debug!("found use of ty param num {}", index);
4480 types_used[index as usize - own_counts.lifetimes] = true;
4481 } else if let ty::Error = leaf_ty.sty {
4482 // If there is already another error, do not emit
4483 // an error for not using a type parameter.
4484 assert!(tcx.sess.has_errors());
4489 let types = generics.params.iter().filter(|param| match param.kind {
4490 ty::GenericParamDefKind::Type { .. } => true,
4493 for (&used, param) in types_used.iter().zip(types) {
4495 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4496 let span = tcx.hir().span(id);
4497 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4498 .span_label(span, "unused type parameter")
4504 fn fatally_break_rust(sess: &Session) {
4505 let handler = sess.diagnostic();
4506 handler.span_bug_no_panic(
4508 "It looks like you're trying to break rust; would you like some ICE?",
4510 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4511 handler.note_without_error(
4512 "we would appreciate a joke overview: \
4513 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4515 handler.note_without_error(&format!("rustc {} running on {}",
4516 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4517 crate::session::config::host_triple(),
4521 fn potentially_plural_count(count: usize, word: &str) -> String {
4522 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })