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::CompilerDesugaringKind;
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/run-pass/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(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 `Some((body_id, decl))`
750 /// with information about it's body-id and fn-decl (if any). Otherwise,
753 /// If this function returns "some", then `typeck_tables(def_id)` will
754 /// succeed; if it returns `None`, then `typeck_tables(def_id)` may or
755 /// may not succeed. In some cases where this function returns `None`
756 /// (notably closures), `typeck_tables(def_id)` would wind up
757 /// redirecting to the owning function.
761 ) -> Option<(hir::BodyId, Option<&hir::FnDecl>)> {
762 match tcx.hir().get(id) {
763 Node::Item(item) => {
765 hir::ItemKind::Const(_, body) |
766 hir::ItemKind::Static(_, _, body) =>
768 hir::ItemKind::Fn(ref decl, .., body) =>
769 Some((body, Some(decl))),
774 Node::TraitItem(item) => {
776 hir::TraitItemKind::Const(_, Some(body)) =>
778 hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) =>
779 Some((body, Some(&sig.decl))),
784 Node::ImplItem(item) => {
786 hir::ImplItemKind::Const(_, body) =>
788 hir::ImplItemKind::Method(ref sig, body) =>
789 Some((body, Some(&sig.decl))),
794 Node::AnonConst(constant) => Some((constant.body, None)),
799 fn has_typeck_tables(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
800 // Closures' tables come from their outermost function,
801 // as they are part of the same "inference environment".
802 let outer_def_id = tcx.closure_base_def_id(def_id);
803 if outer_def_id != def_id {
804 return tcx.has_typeck_tables(outer_def_id);
807 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
808 primary_body_of(tcx, id).is_some()
811 fn used_trait_imports(tcx: TyCtxt<'_>, def_id: DefId) -> &DefIdSet {
812 &*tcx.typeck_tables_of(def_id).used_trait_imports
815 fn typeck_tables_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::TypeckTables<'_> {
816 // Closures' tables come from their outermost function,
817 // as they are part of the same "inference environment".
818 let outer_def_id = tcx.closure_base_def_id(def_id);
819 if outer_def_id != def_id {
820 return tcx.typeck_tables_of(outer_def_id);
823 let id = tcx.hir().as_local_hir_id(def_id).unwrap();
824 let span = tcx.hir().span(id);
826 // Figure out what primary body this item has.
827 let (body_id, fn_decl) = primary_body_of(tcx, id).unwrap_or_else(|| {
828 span_bug!(span, "can't type-check body of {:?}", def_id);
830 let body = tcx.hir().body(body_id);
832 let tables = Inherited::build(tcx, def_id).enter(|inh| {
833 let param_env = tcx.param_env(def_id);
834 let fcx = if let Some(decl) = fn_decl {
835 let fn_sig = tcx.fn_sig(def_id);
837 check_abi(tcx, span, fn_sig.abi());
839 // Compute the fty from point of view of inside the fn.
841 tcx.liberate_late_bound_regions(def_id, &fn_sig);
843 inh.normalize_associated_types_in(body.value.span,
848 let fcx = check_fn(&inh, param_env, fn_sig, decl, id, body, None).0;
851 let fcx = FnCtxt::new(&inh, param_env, body.value.hir_id);
852 let expected_type = tcx.type_of(def_id);
853 let expected_type = fcx.normalize_associated_types_in(body.value.span, &expected_type);
854 fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
856 let revealed_ty = if tcx.features().impl_trait_in_bindings {
857 fcx.instantiate_opaque_types_from_value(
866 // Gather locals in statics (because of block expressions).
867 GatherLocalsVisitor { fcx: &fcx, parent_id: id, }.visit_body(body);
869 fcx.check_expr_coercable_to_type(&body.value, revealed_ty);
871 fcx.write_ty(id, revealed_ty);
876 // All type checking constraints were added, try to fallback unsolved variables.
877 fcx.select_obligations_where_possible(false);
878 let mut fallback_has_occurred = false;
879 for ty in &fcx.unsolved_variables() {
880 fallback_has_occurred |= fcx.fallback_if_possible(ty);
882 fcx.select_obligations_where_possible(fallback_has_occurred);
884 // Even though coercion casts provide type hints, we check casts after fallback for
885 // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
888 // Closure and generator analysis may run after fallback
889 // because they don't constrain other type variables.
890 fcx.closure_analyze(body);
891 assert!(fcx.deferred_call_resolutions.borrow().is_empty());
892 fcx.resolve_generator_interiors(def_id);
894 for (ty, span, code) in fcx.deferred_sized_obligations.borrow_mut().drain(..) {
895 let ty = fcx.normalize_ty(span, ty);
896 fcx.require_type_is_sized(ty, span, code);
898 fcx.select_all_obligations_or_error();
900 if fn_decl.is_some() {
901 fcx.regionck_fn(id, body);
903 fcx.regionck_expr(body);
906 fcx.resolve_type_vars_in_body(body)
909 // Consistency check our TypeckTables instance can hold all ItemLocalIds
910 // it will need to hold.
911 assert_eq!(tables.local_id_root, Some(DefId::local(id.owner)));
916 fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: Abi) {
917 if !tcx.sess.target.target.is_abi_supported(abi) {
918 struct_span_err!(tcx.sess, span, E0570,
919 "The ABI `{}` is not supported for the current target", abi).emit()
923 struct GatherLocalsVisitor<'a, 'tcx> {
924 fcx: &'a FnCtxt<'a, 'tcx>,
925 parent_id: hir::HirId,
928 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
929 fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
932 // infer the variable's type
933 let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
934 kind: TypeVariableOriginKind::TypeInference,
937 self.fcx.locals.borrow_mut().insert(nid, LocalTy {
944 // take type that the user specified
945 self.fcx.locals.borrow_mut().insert(nid, typ);
952 impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
953 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
954 NestedVisitorMap::None
957 // Add explicitly-declared locals.
958 fn visit_local(&mut self, local: &'tcx hir::Local) {
959 let local_ty = match local.ty {
961 let o_ty = self.fcx.to_ty(&ty);
963 let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
964 self.fcx.instantiate_opaque_types_from_value(
973 let c_ty = self.fcx.inh.infcx.canonicalize_user_type_annotation(
974 &UserType::Ty(revealed_ty)
976 debug!("visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
977 ty.hir_id, o_ty, revealed_ty, c_ty);
978 self.fcx.tables.borrow_mut().user_provided_types_mut().insert(ty.hir_id, c_ty);
980 Some(LocalTy { decl_ty: o_ty, revealed_ty })
984 self.assign(local.span, local.hir_id, local_ty);
986 debug!("local variable {:?} is assigned type {}",
988 self.fcx.ty_to_string(
989 self.fcx.locals.borrow().get(&local.hir_id).unwrap().clone().decl_ty));
990 intravisit::walk_local(self, local);
993 // Add pattern bindings.
994 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
995 if let PatKind::Binding(_, _, ident, _) = p.node {
996 let var_ty = self.assign(p.span, p.hir_id, None);
998 if !self.fcx.tcx.features().unsized_locals {
999 self.fcx.require_type_is_sized(var_ty, p.span,
1000 traits::VariableType(p.hir_id));
1003 debug!("pattern binding {} is assigned to {} with type {:?}",
1005 self.fcx.ty_to_string(
1006 self.fcx.locals.borrow().get(&p.hir_id).unwrap().clone().decl_ty),
1009 intravisit::walk_pat(self, p);
1012 // Don't descend into the bodies of nested closures
1015 _: intravisit::FnKind<'tcx>,
1016 _: &'tcx hir::FnDecl,
1023 /// When `check_fn` is invoked on a generator (i.e., a body that
1024 /// includes yield), it returns back some information about the yield
1026 struct GeneratorTypes<'tcx> {
1027 /// Type of value that is yielded.
1030 /// Types that are captured (see `GeneratorInterior` for more).
1033 /// Indicates if the generator is movable or static (immovable).
1034 movability: hir::GeneratorMovability,
1037 /// Helper used for fns and closures. Does the grungy work of checking a function
1038 /// body and returns the function context used for that purpose, since in the case of a fn item
1039 /// there is still a bit more to do.
1042 /// * inherited: other fields inherited from the enclosing fn (if any)
1043 fn check_fn<'a, 'tcx>(
1044 inherited: &'a Inherited<'a, 'tcx>,
1045 param_env: ty::ParamEnv<'tcx>,
1046 fn_sig: ty::FnSig<'tcx>,
1047 decl: &'tcx hir::FnDecl,
1049 body: &'tcx hir::Body,
1050 can_be_generator: Option<hir::GeneratorMovability>,
1051 ) -> (FnCtxt<'a, 'tcx>, Option<GeneratorTypes<'tcx>>) {
1052 let mut fn_sig = fn_sig.clone();
1054 debug!("check_fn(sig={:?}, fn_id={}, param_env={:?})", fn_sig, fn_id, param_env);
1056 // Create the function context. This is either derived from scratch or,
1057 // in the case of closures, based on the outer context.
1058 let mut fcx = FnCtxt::new(inherited, param_env, body.value.hir_id);
1059 *fcx.ps.borrow_mut() = UnsafetyState::function(fn_sig.unsafety, fn_id);
1061 let declared_ret_ty = fn_sig.output();
1062 fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
1063 let revealed_ret_ty = fcx.instantiate_opaque_types_from_value(
1068 debug!("check_fn: declared_ret_ty: {}, revealed_ret_ty: {}", declared_ret_ty, revealed_ret_ty);
1069 fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(revealed_ret_ty)));
1070 fn_sig = fcx.tcx.mk_fn_sig(
1071 fn_sig.inputs().iter().cloned(),
1078 let span = body.value.span;
1080 if body.generator_kind.is_some() && can_be_generator.is_some() {
1081 let yield_ty = fcx.next_ty_var(TypeVariableOrigin {
1082 kind: TypeVariableOriginKind::TypeInference,
1085 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
1086 fcx.yield_ty = Some(yield_ty);
1089 let outer_def_id = fcx.tcx.closure_base_def_id(fcx.tcx.hir().local_def_id(fn_id));
1090 let outer_hir_id = fcx.tcx.hir().as_local_hir_id(outer_def_id).unwrap();
1091 GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id, }.visit_body(body);
1093 // Add formal parameters.
1094 for (arg_ty, arg) in fn_sig.inputs().iter().zip(&body.arguments) {
1095 // Check the pattern.
1096 let binding_mode = ty::BindingMode::BindByValue(hir::Mutability::MutImmutable);
1097 fcx.check_pat_walk(&arg.pat, arg_ty, binding_mode, None);
1099 // Check that argument is Sized.
1100 // The check for a non-trivial pattern is a hack to avoid duplicate warnings
1101 // for simple cases like `fn foo(x: Trait)`,
1102 // where we would error once on the parameter as a whole, and once on the binding `x`.
1103 if arg.pat.simple_ident().is_none() && !fcx.tcx.features().unsized_locals {
1104 fcx.require_type_is_sized(arg_ty, decl.output.span(), traits::SizedArgumentType);
1107 fcx.write_ty(arg.hir_id, arg_ty);
1110 inherited.tables.borrow_mut().liberated_fn_sigs_mut().insert(fn_id, fn_sig);
1112 fcx.check_return_expr(&body.value);
1114 // We insert the deferred_generator_interiors entry after visiting the body.
1115 // This ensures that all nested generators appear before the entry of this generator.
1116 // resolve_generator_interiors relies on this property.
1117 let gen_ty = if let (Some(_), Some(gen_kind)) = (can_be_generator, body.generator_kind) {
1118 let interior = fcx.next_ty_var(TypeVariableOrigin {
1119 kind: TypeVariableOriginKind::MiscVariable,
1122 fcx.deferred_generator_interiors.borrow_mut().push((body.id(), interior, gen_kind));
1123 Some(GeneratorTypes {
1124 yield_ty: fcx.yield_ty.unwrap(),
1126 movability: can_be_generator.unwrap(),
1132 // Finalize the return check by taking the LUB of the return types
1133 // we saw and assigning it to the expected return type. This isn't
1134 // really expected to fail, since the coercions would have failed
1135 // earlier when trying to find a LUB.
1137 // However, the behavior around `!` is sort of complex. In the
1138 // event that the `actual_return_ty` comes back as `!`, that
1139 // indicates that the fn either does not return or "returns" only
1140 // values of type `!`. In this case, if there is an expected
1141 // return type that is *not* `!`, that should be ok. But if the
1142 // return type is being inferred, we want to "fallback" to `!`:
1144 // let x = move || panic!();
1146 // To allow for that, I am creating a type variable with diverging
1147 // fallback. This was deemed ever so slightly better than unifying
1148 // the return value with `!` because it allows for the caller to
1149 // make more assumptions about the return type (e.g., they could do
1151 // let y: Option<u32> = Some(x());
1153 // which would then cause this return type to become `u32`, not
1155 let coercion = fcx.ret_coercion.take().unwrap().into_inner();
1156 let mut actual_return_ty = coercion.complete(&fcx);
1157 if actual_return_ty.is_never() {
1158 actual_return_ty = fcx.next_diverging_ty_var(
1159 TypeVariableOrigin {
1160 kind: TypeVariableOriginKind::DivergingFn,
1165 fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
1167 // Check that the main return type implements the termination trait.
1168 if let Some(term_id) = fcx.tcx.lang_items().termination() {
1169 if let Some((def_id, EntryFnType::Main)) = fcx.tcx.entry_fn(LOCAL_CRATE) {
1170 let main_id = fcx.tcx.hir().as_local_hir_id(def_id).unwrap();
1171 if main_id == fn_id {
1172 let substs = fcx.tcx.mk_substs_trait(declared_ret_ty, &[]);
1173 let trait_ref = ty::TraitRef::new(term_id, substs);
1174 let return_ty_span = decl.output.span();
1175 let cause = traits::ObligationCause::new(
1176 return_ty_span, fn_id, ObligationCauseCode::MainFunctionType);
1178 inherited.register_predicate(
1179 traits::Obligation::new(
1180 cause, param_env, trait_ref.to_predicate()));
1185 // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
1186 if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
1187 if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
1188 if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
1189 // at this point we don't care if there are duplicate handlers or if the handler has
1190 // the wrong signature as this value we'll be used when writing metadata and that
1191 // only happens if compilation succeeded
1192 fcx.tcx.sess.has_panic_handler.try_set_same(true);
1194 if declared_ret_ty.sty != ty::Never {
1195 fcx.tcx.sess.span_err(
1197 "return type should be `!`",
1201 let inputs = fn_sig.inputs();
1202 let span = fcx.tcx.hir().span(fn_id);
1203 if inputs.len() == 1 {
1204 let arg_is_panic_info = match inputs[0].sty {
1205 ty::Ref(region, ty, mutbl) => match ty.sty {
1206 ty::Adt(ref adt, _) => {
1207 adt.did == panic_info_did &&
1208 mutbl == hir::Mutability::MutImmutable &&
1209 *region != RegionKind::ReStatic
1216 if !arg_is_panic_info {
1217 fcx.tcx.sess.span_err(
1218 decl.inputs[0].span,
1219 "argument should be `&PanicInfo`",
1223 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1224 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1225 if !generics.params.is_empty() {
1226 fcx.tcx.sess.span_err(
1228 "should have no type parameters",
1234 let span = fcx.tcx.sess.source_map().def_span(span);
1235 fcx.tcx.sess.span_err(span, "function should have one argument");
1238 fcx.tcx.sess.err("language item required, but not found: `panic_info`");
1243 // Check that a function marked as `#[alloc_error_handler]` has signature `fn(Layout) -> !`
1244 if let Some(alloc_error_handler_did) = fcx.tcx.lang_items().oom() {
1245 if alloc_error_handler_did == fcx.tcx.hir().local_def_id(fn_id) {
1246 if let Some(alloc_layout_did) = fcx.tcx.lang_items().alloc_layout() {
1247 if declared_ret_ty.sty != ty::Never {
1248 fcx.tcx.sess.span_err(
1250 "return type should be `!`",
1254 let inputs = fn_sig.inputs();
1255 let span = fcx.tcx.hir().span(fn_id);
1256 if inputs.len() == 1 {
1257 let arg_is_alloc_layout = match inputs[0].sty {
1258 ty::Adt(ref adt, _) => {
1259 adt.did == alloc_layout_did
1264 if !arg_is_alloc_layout {
1265 fcx.tcx.sess.span_err(
1266 decl.inputs[0].span,
1267 "argument should be `Layout`",
1271 if let Node::Item(item) = fcx.tcx.hir().get(fn_id) {
1272 if let ItemKind::Fn(_, _, ref generics, _) = item.node {
1273 if !generics.params.is_empty() {
1274 fcx.tcx.sess.span_err(
1276 "`#[alloc_error_handler]` function should have no type \
1283 let span = fcx.tcx.sess.source_map().def_span(span);
1284 fcx.tcx.sess.span_err(span, "function should have one argument");
1287 fcx.tcx.sess.err("language item required, but not found: `alloc_layout`");
1295 fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1296 let def_id = tcx.hir().local_def_id(id);
1297 let def = tcx.adt_def(def_id);
1298 def.destructor(tcx); // force the destructor to be evaluated
1299 check_representable(tcx, span, def_id);
1301 if def.repr.simd() {
1302 check_simd(tcx, span, def_id);
1305 check_transparent(tcx, span, def_id);
1306 check_packed(tcx, span, def_id);
1309 fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) {
1310 let def_id = tcx.hir().local_def_id(id);
1311 let def = tcx.adt_def(def_id);
1312 def.destructor(tcx); // force the destructor to be evaluated
1313 check_representable(tcx, span, def_id);
1314 check_transparent(tcx, span, def_id);
1315 check_packed(tcx, span, def_id);
1318 fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, substs: SubstsRef<'tcx>, span: Span) {
1319 if let Err(partially_expanded_type) = tcx.try_expand_impl_trait_type(def_id, substs) {
1320 let mut err = struct_span_err!(
1321 tcx.sess, span, E0720,
1322 "opaque type expands to a recursive type",
1324 err.span_label(span, "expands to self-referential type");
1325 if let ty::Opaque(..) = partially_expanded_type.sty {
1326 err.note("type resolves to itself");
1328 err.note(&format!("expanded type is `{}`", partially_expanded_type));
1334 pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item) {
1336 "check_item_type(it.hir_id={}, it.name={})",
1338 tcx.def_path_str(tcx.hir().local_def_id(it.hir_id))
1340 let _indenter = indenter();
1342 // Consts can play a role in type-checking, so they are included here.
1343 hir::ItemKind::Static(..) => {
1344 let def_id = tcx.hir().local_def_id(it.hir_id);
1345 tcx.typeck_tables_of(def_id);
1346 maybe_check_static_with_link_section(tcx, def_id, it.span);
1348 hir::ItemKind::Const(..) => {
1349 tcx.typeck_tables_of(tcx.hir().local_def_id(it.hir_id));
1351 hir::ItemKind::Enum(ref enum_definition, _) => {
1352 check_enum(tcx, it.span, &enum_definition.variants, it.hir_id);
1354 hir::ItemKind::Fn(..) => {} // entirely within check_item_body
1355 hir::ItemKind::Impl(.., ref impl_item_refs) => {
1356 debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id);
1357 let impl_def_id = tcx.hir().local_def_id(it.hir_id);
1358 if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) {
1359 check_impl_items_against_trait(
1366 let trait_def_id = impl_trait_ref.def_id;
1367 check_on_unimplemented(tcx, trait_def_id, it);
1370 hir::ItemKind::Trait(..) => {
1371 let def_id = tcx.hir().local_def_id(it.hir_id);
1372 check_on_unimplemented(tcx, def_id, it);
1374 hir::ItemKind::Struct(..) => {
1375 check_struct(tcx, it.hir_id, it.span);
1377 hir::ItemKind::Union(..) => {
1378 check_union(tcx, it.hir_id, it.span);
1380 hir::ItemKind::Existential(..) => {
1381 let def_id = tcx.hir().local_def_id(it.hir_id);
1383 let substs = InternalSubsts::identity_for_item(tcx, def_id);
1384 check_opaque(tcx, def_id, substs, it.span);
1386 hir::ItemKind::Ty(..) => {
1387 let def_id = tcx.hir().local_def_id(it.hir_id);
1388 let pty_ty = tcx.type_of(def_id);
1389 let generics = tcx.generics_of(def_id);
1390 check_bounds_are_used(tcx, &generics, pty_ty);
1392 hir::ItemKind::ForeignMod(ref m) => {
1393 check_abi(tcx, it.span, m.abi);
1395 if m.abi == Abi::RustIntrinsic {
1396 for item in &m.items {
1397 intrinsic::check_intrinsic_type(tcx, item);
1399 } else if m.abi == Abi::PlatformIntrinsic {
1400 for item in &m.items {
1401 intrinsic::check_platform_intrinsic_type(tcx, item);
1404 for item in &m.items {
1405 let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id));
1406 if generics.params.len() - generics.own_counts().lifetimes != 0 {
1407 let mut err = struct_span_err!(
1411 "foreign items may not have type parameters"
1413 err.span_label(item.span, "can't have type parameters");
1414 // FIXME: once we start storing spans for type arguments, turn this into a
1417 "use specialization instead of type parameters by replacing them \
1418 with concrete types like `u32`",
1423 if let hir::ForeignItemKind::Fn(ref fn_decl, _, _) = item.node {
1424 require_c_abi_if_c_variadic(tcx, fn_decl, m.abi, item.span);
1429 _ => { /* nothing to do */ }
1433 fn maybe_check_static_with_link_section(tcx: TyCtxt<'_>, id: DefId, span: Span) {
1434 // Only restricted on wasm32 target for now
1435 if !tcx.sess.opts.target_triple.triple().starts_with("wasm32") {
1439 // If `#[link_section]` is missing, then nothing to verify
1440 let attrs = tcx.codegen_fn_attrs(id);
1441 if attrs.link_section.is_none() {
1445 // For the wasm32 target statics with #[link_section] are placed into custom
1446 // sections of the final output file, but this isn't link custom sections of
1447 // other executable formats. Namely we can only embed a list of bytes,
1448 // nothing with pointers to anything else or relocations. If any relocation
1449 // show up, reject them here.
1450 let instance = ty::Instance::mono(tcx, id);
1451 let cid = GlobalId {
1455 let param_env = ty::ParamEnv::reveal_all();
1456 if let Ok(static_) = tcx.const_eval(param_env.and(cid)) {
1457 let alloc = if let ConstValue::ByRef { alloc, .. } = static_.val {
1460 bug!("Matching on non-ByRef static")
1462 if alloc.relocations.len() != 0 {
1463 let msg = "statics with a custom `#[link_section]` must be a \
1464 simple list of bytes on the wasm target with no \
1465 extra levels of indirection such as references";
1466 tcx.sess.span_err(span, msg);
1471 fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item) {
1472 let item_def_id = tcx.hir().local_def_id(item.hir_id);
1473 // an error would be reported if this fails.
1474 let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id);
1477 fn report_forbidden_specialization(
1479 impl_item: &hir::ImplItem,
1482 let mut err = struct_span_err!(
1483 tcx.sess, impl_item.span, E0520,
1484 "`{}` specializes an item from a parent `impl`, but \
1485 that item is not marked `default`",
1487 err.span_label(impl_item.span, format!("cannot specialize default item `{}`",
1490 match tcx.span_of_impl(parent_impl) {
1492 err.span_label(span, "parent `impl` is here");
1493 err.note(&format!("to specialize, `{}` in the parent `impl` must be marked `default`",
1497 err.note(&format!("parent implementation is in crate `{}`", cname));
1504 fn check_specialization_validity<'tcx>(
1506 trait_def: &ty::TraitDef,
1507 trait_item: &ty::AssocItem,
1509 impl_item: &hir::ImplItem,
1511 let ancestors = trait_def.ancestors(tcx, impl_id);
1513 let kind = match impl_item.node {
1514 hir::ImplItemKind::Const(..) => ty::AssocKind::Const,
1515 hir::ImplItemKind::Method(..) => ty::AssocKind::Method,
1516 hir::ImplItemKind::Existential(..) => ty::AssocKind::Existential,
1517 hir::ImplItemKind::Type(_) => ty::AssocKind::Type
1520 let parent = ancestors.defs(tcx, trait_item.ident, kind, trait_def.def_id).nth(1)
1521 .map(|node_item| node_item.map(|parent| parent.defaultness));
1523 if let Some(parent) = parent {
1524 if tcx.impl_item_is_final(&parent) {
1525 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
1531 fn check_impl_items_against_trait<'tcx>(
1535 impl_trait_ref: ty::TraitRef<'tcx>,
1536 impl_item_refs: &[hir::ImplItemRef],
1538 let impl_span = tcx.sess.source_map().def_span(impl_span);
1540 // If the trait reference itself is erroneous (so the compilation is going
1541 // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1542 // isn't populated for such impls.
1543 if impl_trait_ref.references_error() { return; }
1545 // Locate trait definition and items
1546 let trait_def = tcx.trait_def(impl_trait_ref.def_id);
1547 let mut overridden_associated_type = None;
1549 let impl_items = || impl_item_refs.iter().map(|iiref| tcx.hir().impl_item(iiref.id));
1551 // Check existing impl methods to see if they are both present in trait
1552 // and compatible with trait signature
1553 for impl_item in impl_items() {
1554 let ty_impl_item = tcx.associated_item(
1555 tcx.hir().local_def_id(impl_item.hir_id));
1556 let ty_trait_item = tcx.associated_items(impl_trait_ref.def_id)
1557 .find(|ac| Namespace::from(&impl_item.node) == Namespace::from(ac.kind) &&
1558 tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1560 // Not compatible, but needed for the error message
1561 tcx.associated_items(impl_trait_ref.def_id)
1562 .find(|ac| tcx.hygienic_eq(ty_impl_item.ident, ac.ident, impl_trait_ref.def_id))
1565 // Check that impl definition matches trait definition
1566 if let Some(ty_trait_item) = ty_trait_item {
1567 match impl_item.node {
1568 hir::ImplItemKind::Const(..) => {
1569 // Find associated const definition.
1570 if ty_trait_item.kind == ty::AssocKind::Const {
1571 compare_const_impl(tcx,
1577 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0323,
1578 "item `{}` is an associated const, \
1579 which doesn't match its trait `{}`",
1582 err.span_label(impl_item.span, "does not match trait");
1583 // We can only get the spans from local trait definition
1584 // Same for E0324 and E0325
1585 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1586 err.span_label(trait_span, "item in trait");
1591 hir::ImplItemKind::Method(..) => {
1592 let trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
1593 if ty_trait_item.kind == ty::AssocKind::Method {
1594 compare_impl_method(tcx,
1601 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
1602 "item `{}` is an associated method, \
1603 which doesn't match its trait `{}`",
1606 err.span_label(impl_item.span, "does not match trait");
1607 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1608 err.span_label(trait_span, "item in trait");
1613 hir::ImplItemKind::Existential(..) |
1614 hir::ImplItemKind::Type(_) => {
1615 if ty_trait_item.kind == ty::AssocKind::Type {
1616 if ty_trait_item.defaultness.has_value() {
1617 overridden_associated_type = Some(impl_item);
1620 let mut err = struct_span_err!(tcx.sess, impl_item.span, E0325,
1621 "item `{}` is an associated type, \
1622 which doesn't match its trait `{}`",
1625 err.span_label(impl_item.span, "does not match trait");
1626 if let Some(trait_span) = tcx.hir().span_if_local(ty_trait_item.def_id) {
1627 err.span_label(trait_span, "item in trait");
1634 check_specialization_validity(tcx, trait_def, &ty_trait_item, impl_id, impl_item);
1638 // Check for missing items from trait
1639 let mut missing_items = Vec::new();
1640 let mut invalidated_items = Vec::new();
1641 let associated_type_overridden = overridden_associated_type.is_some();
1642 for trait_item in tcx.associated_items(impl_trait_ref.def_id) {
1643 let is_implemented = trait_def.ancestors(tcx, impl_id)
1644 .defs(tcx, trait_item.ident, trait_item.kind, impl_trait_ref.def_id)
1646 .map(|node_item| !node_item.node.is_from_trait())
1649 if !is_implemented && !tcx.impl_is_default(impl_id) {
1650 if !trait_item.defaultness.has_value() {
1651 missing_items.push(trait_item);
1652 } else if associated_type_overridden {
1653 invalidated_items.push(trait_item.ident);
1658 if !missing_items.is_empty() {
1659 let mut err = struct_span_err!(tcx.sess, impl_span, E0046,
1660 "not all trait items implemented, missing: `{}`",
1661 missing_items.iter()
1662 .map(|trait_item| trait_item.ident.to_string())
1663 .collect::<Vec<_>>().join("`, `"));
1664 err.span_label(impl_span, format!("missing `{}` in implementation",
1665 missing_items.iter()
1666 .map(|trait_item| trait_item.ident.to_string())
1667 .collect::<Vec<_>>().join("`, `")));
1668 for trait_item in missing_items {
1669 if let Some(span) = tcx.hir().span_if_local(trait_item.def_id) {
1670 err.span_label(span, format!("`{}` from trait", trait_item.ident));
1672 err.note_trait_signature(trait_item.ident.to_string(),
1673 trait_item.signature(tcx));
1679 if !invalidated_items.is_empty() {
1680 let invalidator = overridden_associated_type.unwrap();
1681 span_err!(tcx.sess, invalidator.span, E0399,
1682 "the following trait items need to be reimplemented \
1683 as `{}` was overridden: `{}`",
1685 invalidated_items.iter()
1686 .map(|name| name.to_string())
1687 .collect::<Vec<_>>().join("`, `"))
1691 /// Checks whether a type can be represented in memory. In particular, it
1692 /// identifies types that contain themselves without indirection through a
1693 /// pointer, which would mean their size is unbounded.
1694 fn check_representable(tcx: TyCtxt<'_>, sp: Span, item_def_id: DefId) -> bool {
1695 let rty = tcx.type_of(item_def_id);
1697 // Check that it is possible to represent this type. This call identifies
1698 // (1) types that contain themselves and (2) types that contain a different
1699 // recursive type. It is only necessary to throw an error on those that
1700 // contain themselves. For case 2, there must be an inner type that will be
1701 // caught by case 1.
1702 match rty.is_representable(tcx, sp) {
1703 Representability::SelfRecursive(spans) => {
1704 let mut err = tcx.recursive_type_with_infinite_size_error(item_def_id);
1706 err.span_label(span, "recursive without indirection");
1711 Representability::Representable | Representability::ContainsRecursive => (),
1716 pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1717 let t = tcx.type_of(def_id);
1718 if let ty::Adt(def, substs) = t.sty {
1719 if def.is_struct() {
1720 let fields = &def.non_enum_variant().fields;
1721 if fields.is_empty() {
1722 span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
1725 let e = fields[0].ty(tcx, substs);
1726 if !fields.iter().all(|f| f.ty(tcx, substs) == e) {
1727 struct_span_err!(tcx.sess, sp, E0076, "SIMD vector should be homogeneous")
1728 .span_label(sp, "SIMD elements must have the same type")
1733 ty::Param(_) => { /* struct<T>(T, T, T, T) is ok */ }
1734 _ if e.is_machine() => { /* struct(u8, u8, u8, u8) is ok */ }
1736 span_err!(tcx.sess, sp, E0077,
1737 "SIMD vector element type should be machine type");
1745 fn check_packed(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1746 let repr = tcx.adt_def(def_id).repr;
1748 for attr in tcx.get_attrs(def_id).iter() {
1749 for r in attr::find_repr_attrs(&tcx.sess.parse_sess, attr) {
1750 if let attr::ReprPacked(pack) = r {
1751 if pack != repr.pack {
1752 struct_span_err!(tcx.sess, sp, E0634,
1753 "type has conflicting packed representation hints").emit();
1759 struct_span_err!(tcx.sess, sp, E0587,
1760 "type has conflicting packed and align representation hints").emit();
1762 else if check_packed_inner(tcx, def_id, &mut Vec::new()) {
1763 struct_span_err!(tcx.sess, sp, E0588,
1764 "packed type cannot transitively contain a `[repr(align)]` type").emit();
1769 fn check_packed_inner(tcx: TyCtxt<'_>, def_id: DefId, stack: &mut Vec<DefId>) -> bool {
1770 let t = tcx.type_of(def_id);
1771 if stack.contains(&def_id) {
1772 debug!("check_packed_inner: {:?} is recursive", t);
1775 if let ty::Adt(def, substs) = t.sty {
1776 if def.is_struct() || def.is_union() {
1777 if tcx.adt_def(def.did).repr.align > 0 {
1780 // push struct def_id before checking fields
1782 for field in &def.non_enum_variant().fields {
1783 let f = field.ty(tcx, substs);
1784 if let ty::Adt(def, _) = f.sty {
1785 if check_packed_inner(tcx, def.did, stack) {
1790 // only need to pop if not early out
1797 /// Emit an error when encountering more or less than one variant in a transparent enum.
1798 fn bad_variant_count<'tcx>(tcx: TyCtxt<'tcx>, adt: &'tcx ty::AdtDef, sp: Span, did: DefId) {
1799 let variant_spans: Vec<_> = adt.variants.iter().map(|variant| {
1800 tcx.hir().span_if_local(variant.def_id).unwrap()
1803 "needs exactly one variant, but has {}",
1806 let mut err = struct_span_err!(tcx.sess, sp, E0731, "transparent enum {}", msg);
1807 err.span_label(sp, &msg);
1808 if let &[ref start.., ref end] = &variant_spans[..] {
1809 for variant_span in start {
1810 err.span_label(*variant_span, "");
1812 err.span_label(*end, &format!("too many variants in `{}`", tcx.def_path_str(did)));
1817 /// Emit an error when encountering more or less than one non-zero-sized field in a transparent
1819 fn bad_non_zero_sized_fields<'tcx>(
1821 adt: &'tcx ty::AdtDef,
1823 field_spans: impl Iterator<Item = Span>,
1826 let msg = format!("needs exactly one non-zero-sized field, but has {}", field_count);
1827 let mut err = struct_span_err!(
1831 "{}transparent {} {}",
1832 if adt.is_enum() { "the variant of a " } else { "" },
1836 err.span_label(sp, &msg);
1837 for sp in field_spans {
1838 err.span_label(sp, "this field is non-zero-sized");
1843 fn check_transparent(tcx: TyCtxt<'_>, sp: Span, def_id: DefId) {
1844 let adt = tcx.adt_def(def_id);
1845 if !adt.repr.transparent() {
1848 let sp = tcx.sess.source_map().def_span(sp);
1851 if !tcx.features().transparent_enums {
1853 &tcx.sess.parse_sess,
1854 sym::transparent_enums,
1856 GateIssue::Language,
1857 "transparent enums are unstable",
1860 if adt.variants.len() != 1 {
1861 bad_variant_count(tcx, adt, sp, def_id);
1862 if adt.variants.is_empty() {
1863 // Don't bother checking the fields. No variants (and thus no fields) exist.
1869 if adt.is_union() && !tcx.features().transparent_unions {
1870 emit_feature_err(&tcx.sess.parse_sess,
1871 sym::transparent_unions,
1873 GateIssue::Language,
1874 "transparent unions are unstable");
1877 // For each field, figure out if it's known to be a ZST and align(1)
1878 let field_infos = adt.all_fields().map(|field| {
1879 let ty = field.ty(tcx, InternalSubsts::identity_for_item(tcx, field.did));
1880 let param_env = tcx.param_env(field.did);
1881 let layout = tcx.layout_of(param_env.and(ty));
1882 // We are currently checking the type this field came from, so it must be local
1883 let span = tcx.hir().span_if_local(field.did).unwrap();
1884 let zst = layout.map(|layout| layout.is_zst()).unwrap_or(false);
1885 let align1 = layout.map(|layout| layout.align.abi.bytes() == 1).unwrap_or(false);
1889 let non_zst_fields = field_infos.clone().filter_map(|(span, zst, _align1)| if !zst {
1894 let non_zst_count = non_zst_fields.clone().count();
1895 if non_zst_count != 1 {
1896 bad_non_zero_sized_fields(tcx, adt, non_zst_count, non_zst_fields, sp);
1898 for (span, zst, align1) in field_infos {
1904 "zero-sized field in transparent {} has alignment larger than 1",
1906 ).span_label(span, "has alignment larger than 1").emit();
1911 #[allow(trivial_numeric_casts)]
1912 pub fn check_enum<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant], id: hir::HirId) {
1913 let def_id = tcx.hir().local_def_id(id);
1914 let def = tcx.adt_def(def_id);
1915 def.destructor(tcx); // force the destructor to be evaluated
1918 let attributes = tcx.get_attrs(def_id);
1919 if let Some(attr) = attr::find_by_name(&attributes, sym::repr) {
1921 tcx.sess, attr.span, E0084,
1922 "unsupported representation for zero-variant enum")
1923 .span_label(sp, "zero-variant enum")
1928 let repr_type_ty = def.repr.discr_type().to_ty(tcx);
1929 if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 {
1930 if !tcx.features().repr128 {
1931 emit_feature_err(&tcx.sess.parse_sess,
1934 GateIssue::Language,
1935 "repr with 128-bit type is unstable");
1940 if let Some(ref e) = v.node.disr_expr {
1941 tcx.typeck_tables_of(tcx.hir().local_def_id(e.hir_id));
1945 if tcx.adt_def(def_id).repr.int.is_none() && tcx.features().arbitrary_enum_discriminant {
1947 |var: &hir::Variant| match var.node.data {
1948 hir::VariantData::Unit(..) => true,
1952 let has_disr = |var: &hir::Variant| var.node.disr_expr.is_some();
1953 let has_non_units = vs.iter().any(|var| !is_unit(var));
1954 let disr_units = vs.iter().any(|var| is_unit(&var) && has_disr(&var));
1955 let disr_non_unit = vs.iter().any(|var| !is_unit(&var) && has_disr(&var));
1957 if disr_non_unit || (disr_units && has_non_units) {
1958 let mut err = struct_span_err!(tcx.sess, sp, E0732,
1959 "`#[repr(inttype)]` must be specified");
1964 let mut disr_vals: Vec<Discr<'tcx>> = Vec::with_capacity(vs.len());
1965 for ((_, discr), v) in def.discriminants(tcx).zip(vs) {
1966 // Check for duplicate discriminant values
1967 if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) {
1968 let variant_did = def.variants[VariantIdx::new(i)].def_id;
1969 let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap();
1970 let variant_i = tcx.hir().expect_variant(variant_i_hir_id);
1971 let i_span = match variant_i.node.disr_expr {
1972 Some(ref expr) => tcx.hir().span(expr.hir_id),
1973 None => tcx.hir().span(variant_i_hir_id)
1975 let span = match v.node.disr_expr {
1976 Some(ref expr) => tcx.hir().span(expr.hir_id),
1979 struct_span_err!(tcx.sess, span, E0081,
1980 "discriminant value `{}` already exists", disr_vals[i])
1981 .span_label(i_span, format!("first use of `{}`", disr_vals[i]))
1982 .span_label(span , format!("enum already has `{}`", disr_vals[i]))
1985 disr_vals.push(discr);
1988 check_representable(tcx, sp, def_id);
1989 check_transparent(tcx, sp, def_id);
1992 fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span, qpath: &QPath) {
1993 span_err!(tcx.sess, span, E0533,
1994 "expected unit struct/variant or constant, found {} `{}`",
1996 hir::print::to_string(tcx.hir(), |s| s.print_qpath(qpath, false)));
1999 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
2000 fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
2004 fn get_type_parameter_bounds(&self, _: Span, def_id: DefId)
2005 -> &'tcx ty::GenericPredicates<'tcx>
2008 let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
2009 let item_id = tcx.hir().ty_param_owner(hir_id);
2010 let item_def_id = tcx.hir().local_def_id(item_id);
2011 let generics = tcx.generics_of(item_def_id);
2012 let index = generics.param_def_id_to_index[&def_id];
2013 tcx.arena.alloc(ty::GenericPredicates {
2015 predicates: self.param_env.caller_bounds.iter().filter_map(|&predicate| {
2017 ty::Predicate::Trait(ref data)
2018 if data.skip_binder().self_ty().is_param(index) => {
2019 // HACK(eddyb) should get the original `Span`.
2020 let span = tcx.def_span(def_id);
2021 Some((predicate, span))
2031 def: Option<&ty::GenericParamDef>,
2033 ) -> Option<ty::Region<'tcx>> {
2035 Some(def) => infer::EarlyBoundRegion(span, def.name),
2036 None => infer::MiscVariable(span)
2038 Some(self.next_region_var(v))
2041 fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
2042 if let Some(param) = param {
2043 if let UnpackedKind::Type(ty) = self.var_for_def(span, param).unpack() {
2048 self.next_ty_var(TypeVariableOrigin {
2049 kind: TypeVariableOriginKind::TypeInference,
2058 param: Option<&ty::GenericParamDef>,
2060 ) -> &'tcx Const<'tcx> {
2061 if let Some(param) = param {
2062 if let UnpackedKind::Const(ct) = self.var_for_def(span, param).unpack() {
2067 self.next_const_var(ty, ConstVariableOrigin {
2068 kind: ConstVariableOriginKind::ConstInference,
2074 fn projected_ty_from_poly_trait_ref(&self,
2077 poly_trait_ref: ty::PolyTraitRef<'tcx>)
2080 let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
2082 infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
2086 self.tcx().mk_projection(item_def_id, trait_ref.substs)
2089 fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
2090 if ty.has_escaping_bound_vars() {
2091 ty // FIXME: normalization and escaping regions
2093 self.normalize_associated_types_in(span, &ty)
2097 fn set_tainted_by_errors(&self) {
2098 self.infcx.set_tainted_by_errors()
2101 fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
2102 self.write_ty(hir_id, ty)
2106 /// Controls whether the arguments are tupled. This is used for the call
2109 /// Tupling means that all call-side arguments are packed into a tuple and
2110 /// passed as a single parameter. For example, if tupling is enabled, this
2113 /// fn f(x: (isize, isize))
2115 /// Can be called as:
2122 #[derive(Clone, Eq, PartialEq)]
2123 enum TupleArgumentsFlag {
2128 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2130 inh: &'a Inherited<'a, 'tcx>,
2131 param_env: ty::ParamEnv<'tcx>,
2132 body_id: hir::HirId,
2133 ) -> FnCtxt<'a, 'tcx> {
2137 err_count_on_creation: inh.tcx.sess.err_count(),
2139 ret_coercion_span: RefCell::new(None),
2141 ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal,
2142 hir::CRATE_HIR_ID)),
2143 diverges: Cell::new(Diverges::Maybe),
2144 has_errors: Cell::new(false),
2145 enclosing_breakables: RefCell::new(EnclosingBreakables {
2147 by_id: Default::default(),
2153 pub fn sess(&self) -> &Session {
2157 pub fn errors_reported_since_creation(&self) -> bool {
2158 self.tcx.sess.err_count() > self.err_count_on_creation
2161 /// Produces warning on the given node, if the current point in the
2162 /// function is unreachable, and there hasn't been another warning.
2163 fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
2164 if self.diverges.get() == Diverges::Always &&
2165 // If span arose from a desugaring of `if` or `while`, then it is the condition itself,
2166 // which diverges, that we are about to lint on. This gives suboptimal diagnostics.
2167 // Instead, stop here so that the `if`- or `while`-expression's block is linted instead.
2168 !span.is_compiler_desugaring(CompilerDesugaringKind::CondTemporary) {
2169 self.diverges.set(Diverges::WarnedAlways);
2171 debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
2173 let msg = format!("unreachable {}", kind);
2174 self.tcx().lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg);
2180 code: ObligationCauseCode<'tcx>)
2181 -> ObligationCause<'tcx> {
2182 ObligationCause::new(span, self.body_id, code)
2185 pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
2186 self.cause(span, ObligationCauseCode::MiscObligation)
2189 /// Resolves type variables in `ty` if possible. Unlike the infcx
2190 /// version (resolve_vars_if_possible), this version will
2191 /// also select obligations if it seems useful, in an effort
2192 /// to get more type information.
2193 fn resolve_type_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
2194 debug!("resolve_type_vars_with_obligations(ty={:?})", ty);
2196 // No Infer()? Nothing needs doing.
2197 if !ty.has_infer_types() {
2198 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2202 // If `ty` is a type variable, see whether we already know what it is.
2203 ty = self.resolve_vars_if_possible(&ty);
2204 if !ty.has_infer_types() {
2205 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2209 // If not, try resolving pending obligations as much as
2210 // possible. This can help substantially when there are
2211 // indirect dependencies that don't seem worth tracking
2213 self.select_obligations_where_possible(false);
2214 ty = self.resolve_vars_if_possible(&ty);
2216 debug!("resolve_type_vars_with_obligations: ty={:?}", ty);
2220 fn record_deferred_call_resolution(
2222 closure_def_id: DefId,
2223 r: DeferredCallResolution<'tcx>,
2225 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2226 deferred_call_resolutions.entry(closure_def_id).or_default().push(r);
2229 fn remove_deferred_call_resolutions(
2231 closure_def_id: DefId,
2232 ) -> Vec<DeferredCallResolution<'tcx>> {
2233 let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
2234 deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
2237 pub fn tag(&self) -> String {
2238 format!("{:p}", self)
2241 pub fn local_ty(&self, span: Span, nid: hir::HirId) -> LocalTy<'tcx> {
2242 self.locals.borrow().get(&nid).cloned().unwrap_or_else(||
2243 span_bug!(span, "no type for local variable {}",
2244 self.tcx.hir().node_to_string(nid))
2249 pub fn write_ty(&self, id: hir::HirId, ty: Ty<'tcx>) {
2250 debug!("write_ty({:?}, {:?}) in fcx {}",
2251 id, self.resolve_vars_if_possible(&ty), self.tag());
2252 self.tables.borrow_mut().node_types_mut().insert(id, ty);
2254 if ty.references_error() {
2255 self.has_errors.set(true);
2256 self.set_tainted_by_errors();
2260 pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
2261 self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
2264 fn write_resolution(&self, hir_id: hir::HirId, r: Result<(DefKind, DefId), ErrorReported>) {
2265 self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, r);
2268 pub fn write_method_call(&self,
2270 method: MethodCallee<'tcx>) {
2271 debug!("write_method_call(hir_id={:?}, method={:?})", hir_id, method);
2272 self.write_resolution(hir_id, Ok((DefKind::Method, method.def_id)));
2273 self.write_substs(hir_id, method.substs);
2275 // When the method is confirmed, the `method.substs` includes
2276 // parameters from not just the method, but also the impl of
2277 // the method -- in particular, the `Self` type will be fully
2278 // resolved. However, those are not something that the "user
2279 // specified" -- i.e., those types come from the inferred type
2280 // of the receiver, not something the user wrote. So when we
2281 // create the user-substs, we want to replace those earlier
2282 // types with just the types that the user actually wrote --
2283 // that is, those that appear on the *method itself*.
2285 // As an example, if the user wrote something like
2286 // `foo.bar::<u32>(...)` -- the `Self` type here will be the
2287 // type of `foo` (possibly adjusted), but we don't want to
2288 // include that. We want just the `[_, u32]` part.
2289 if !method.substs.is_noop() {
2290 let method_generics = self.tcx.generics_of(method.def_id);
2291 if !method_generics.params.is_empty() {
2292 let user_type_annotation = self.infcx.probe(|_| {
2293 let user_substs = UserSubsts {
2294 substs: InternalSubsts::for_item(self.tcx, method.def_id, |param, _| {
2295 let i = param.index as usize;
2296 if i < method_generics.parent_count {
2297 self.infcx.var_for_def(DUMMY_SP, param)
2302 user_self_ty: None, // not relevant here
2305 self.infcx.canonicalize_user_type_annotation(&UserType::TypeOf(
2311 debug!("write_method_call: user_type_annotation={:?}", user_type_annotation);
2312 self.write_user_type_annotation(hir_id, user_type_annotation);
2317 pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) {
2318 if !substs.is_noop() {
2319 debug!("write_substs({:?}, {:?}) in fcx {}",
2324 self.tables.borrow_mut().node_substs_mut().insert(node_id, substs);
2328 /// Given the substs that we just converted from the HIR, try to
2329 /// canonicalize them and store them as user-given substitutions
2330 /// (i.e., substitutions that must be respected by the NLL check).
2332 /// This should be invoked **before any unifications have
2333 /// occurred**, so that annotations like `Vec<_>` are preserved
2335 pub fn write_user_type_annotation_from_substs(
2339 substs: SubstsRef<'tcx>,
2340 user_self_ty: Option<UserSelfTy<'tcx>>,
2343 "write_user_type_annotation_from_substs: hir_id={:?} def_id={:?} substs={:?} \
2344 user_self_ty={:?} in fcx {}",
2345 hir_id, def_id, substs, user_self_ty, self.tag(),
2348 if Self::can_contain_user_lifetime_bounds((substs, user_self_ty)) {
2349 let canonicalized = self.infcx.canonicalize_user_type_annotation(
2350 &UserType::TypeOf(def_id, UserSubsts {
2355 debug!("write_user_type_annotation_from_substs: canonicalized={:?}", canonicalized);
2356 self.write_user_type_annotation(hir_id, canonicalized);
2360 pub fn write_user_type_annotation(
2363 canonical_user_type_annotation: CanonicalUserType<'tcx>,
2366 "write_user_type_annotation: hir_id={:?} canonical_user_type_annotation={:?} tag={}",
2367 hir_id, canonical_user_type_annotation, self.tag(),
2370 if !canonical_user_type_annotation.is_identity() {
2371 self.tables.borrow_mut().user_provided_types_mut().insert(
2372 hir_id, canonical_user_type_annotation
2375 debug!("write_user_type_annotation: skipping identity substs");
2379 pub fn apply_adjustments(&self, expr: &hir::Expr, adj: Vec<Adjustment<'tcx>>) {
2380 debug!("apply_adjustments(expr={:?}, adj={:?})", expr, adj);
2386 match self.tables.borrow_mut().adjustments_mut().entry(expr.hir_id) {
2387 Entry::Vacant(entry) => { entry.insert(adj); },
2388 Entry::Occupied(mut entry) => {
2389 debug!(" - composing on top of {:?}", entry.get());
2390 match (&entry.get()[..], &adj[..]) {
2391 // Applying any adjustment on top of a NeverToAny
2392 // is a valid NeverToAny adjustment, because it can't
2394 (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
2396 Adjustment { kind: Adjust::Deref(_), .. },
2397 Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
2399 Adjustment { kind: Adjust::Deref(_), .. },
2400 .. // Any following adjustments are allowed.
2402 // A reborrow has no effect before a dereference.
2404 // FIXME: currently we never try to compose autoderefs
2405 // and ReifyFnPointer/UnsafeFnPointer, but we could.
2407 bug!("while adjusting {:?}, can't compose {:?} and {:?}",
2408 expr, entry.get(), adj)
2410 *entry.get_mut() = adj;
2415 /// Basically whenever we are converting from a type scheme into
2416 /// the fn body space, we always want to normalize associated
2417 /// types as well. This function combines the two.
2418 fn instantiate_type_scheme<T>(&self,
2420 substs: SubstsRef<'tcx>,
2423 where T : TypeFoldable<'tcx>
2425 let value = value.subst(self.tcx, substs);
2426 let result = self.normalize_associated_types_in(span, &value);
2427 debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
2434 /// As `instantiate_type_scheme`, but for the bounds found in a
2435 /// generic type scheme.
2436 fn instantiate_bounds(&self, span: Span, def_id: DefId, substs: SubstsRef<'tcx>)
2437 -> ty::InstantiatedPredicates<'tcx> {
2438 let bounds = self.tcx.predicates_of(def_id);
2439 let result = bounds.instantiate(self.tcx, substs);
2440 let result = self.normalize_associated_types_in(span, &result);
2441 debug!("instantiate_bounds(bounds={:?}, substs={:?}) = {:?}",
2448 /// Replaces the opaque types from the given value with type variables,
2449 /// and records the `OpaqueTypeMap` for later use during writeback. See
2450 /// `InferCtxt::instantiate_opaque_types` for more details.
2451 fn instantiate_opaque_types_from_value<T: TypeFoldable<'tcx>>(
2453 parent_id: hir::HirId,
2457 let parent_def_id = self.tcx.hir().local_def_id(parent_id);
2458 debug!("instantiate_opaque_types_from_value(parent_def_id={:?}, value={:?})",
2462 let (value, opaque_type_map) = self.register_infer_ok_obligations(
2463 self.instantiate_opaque_types(
2472 let mut opaque_types = self.opaque_types.borrow_mut();
2473 for (ty, decl) in opaque_type_map {
2474 let old_value = opaque_types.insert(ty, decl);
2475 assert!(old_value.is_none(), "instantiated twice: {:?}/{:?}", ty, decl);
2481 fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
2482 where T : TypeFoldable<'tcx>
2484 self.inh.normalize_associated_types_in(span, self.body_id, self.param_env, value)
2487 fn normalize_associated_types_in_as_infer_ok<T>(&self, span: Span, value: &T)
2489 where T : TypeFoldable<'tcx>
2491 self.inh.partially_normalize_associated_types_in(span,
2497 pub fn require_type_meets(&self,
2500 code: traits::ObligationCauseCode<'tcx>,
2503 self.register_bound(
2506 traits::ObligationCause::new(span, self.body_id, code));
2509 pub fn require_type_is_sized(&self,
2512 code: traits::ObligationCauseCode<'tcx>)
2514 let lang_item = self.tcx.require_lang_item(lang_items::SizedTraitLangItem);
2515 self.require_type_meets(ty, span, code, lang_item);
2518 pub fn require_type_is_sized_deferred(&self,
2521 code: traits::ObligationCauseCode<'tcx>)
2523 self.deferred_sized_obligations.borrow_mut().push((ty, span, code));
2526 pub fn register_bound(&self,
2529 cause: traits::ObligationCause<'tcx>)
2531 self.fulfillment_cx.borrow_mut()
2532 .register_bound(self, self.param_env, ty, def_id, cause);
2535 pub fn to_ty(&self, ast_t: &hir::Ty) -> Ty<'tcx> {
2536 let t = AstConv::ast_ty_to_ty(self, ast_t);
2537 self.register_wf_obligation(t, ast_t.span, traits::MiscObligation);
2541 pub fn to_ty_saving_user_provided_ty(&self, ast_ty: &hir::Ty) -> Ty<'tcx> {
2542 let ty = self.to_ty(ast_ty);
2543 debug!("to_ty_saving_user_provided_ty: ty={:?}", ty);
2545 if Self::can_contain_user_lifetime_bounds(ty) {
2546 let c_ty = self.infcx.canonicalize_response(&UserType::Ty(ty));
2547 debug!("to_ty_saving_user_provided_ty: c_ty={:?}", c_ty);
2548 self.tables.borrow_mut().user_provided_types_mut().insert(ast_ty.hir_id, c_ty);
2554 /// Returns the `DefId` of the constant parameter that the provided expression is a path to.
2555 pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> {
2556 AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value)
2559 pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2560 AstConv::ast_const_to_const(self, ast_c, ty)
2563 // If the type given by the user has free regions, save it for later, since
2564 // NLL would like to enforce those. Also pass in types that involve
2565 // projections, since those can resolve to `'static` bounds (modulo #54940,
2566 // which hopefully will be fixed by the time you see this comment, dear
2567 // reader, although I have my doubts). Also pass in types with inference
2568 // types, because they may be repeated. Other sorts of things are already
2569 // sufficiently enforced with erased regions. =)
2570 fn can_contain_user_lifetime_bounds<T>(t: T) -> bool
2572 T: TypeFoldable<'tcx>
2574 t.has_free_regions() || t.has_projections() || t.has_infer_types()
2577 pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
2578 match self.tables.borrow().node_types().get(id) {
2580 None if self.is_tainted_by_errors() => self.tcx.types.err,
2582 bug!("no type for node {}: {} in fcx {}",
2583 id, self.tcx.hir().node_to_string(id),
2589 /// Registers an obligation for checking later, during regionck, that the type `ty` must
2590 /// outlive the region `r`.
2591 pub fn register_wf_obligation(&self,
2594 code: traits::ObligationCauseCode<'tcx>)
2596 // WF obligations never themselves fail, so no real need to give a detailed cause:
2597 let cause = traits::ObligationCause::new(span, self.body_id, code);
2598 self.register_predicate(traits::Obligation::new(cause,
2600 ty::Predicate::WellFormed(ty)));
2603 /// Registers obligations that all types appearing in `substs` are well-formed.
2604 pub fn add_wf_bounds(&self, substs: SubstsRef<'tcx>, expr: &hir::Expr) {
2605 for ty in substs.types() {
2606 self.register_wf_obligation(ty, expr.span, traits::MiscObligation);
2610 /// Given a fully substituted set of bounds (`generic_bounds`), and the values with which each
2611 /// type/region parameter was instantiated (`substs`), creates and registers suitable
2612 /// trait/region obligations.
2614 /// For example, if there is a function:
2617 /// fn foo<'a,T:'a>(...)
2620 /// and a reference:
2626 /// Then we will create a fresh region variable `'$0` and a fresh type variable `$1` for `'a`
2627 /// and `T`. This routine will add a region obligation `$1:'$0` and register it locally.
2628 pub fn add_obligations_for_parameters(&self,
2629 cause: traits::ObligationCause<'tcx>,
2630 predicates: &ty::InstantiatedPredicates<'tcx>)
2632 assert!(!predicates.has_escaping_bound_vars());
2634 debug!("add_obligations_for_parameters(predicates={:?})",
2637 for obligation in traits::predicates_for_generics(cause, self.param_env, predicates) {
2638 self.register_predicate(obligation);
2642 // FIXME(arielb1): use this instead of field.ty everywhere
2643 // Only for fields! Returns <none> for methods>
2644 // Indifferent to privacy flags
2645 pub fn field_ty(&self,
2647 field: &'tcx ty::FieldDef,
2648 substs: SubstsRef<'tcx>)
2651 self.normalize_associated_types_in(span, &field.ty(self.tcx, substs))
2654 fn check_casts(&self) {
2655 let mut deferred_cast_checks = self.deferred_cast_checks.borrow_mut();
2656 for cast in deferred_cast_checks.drain(..) {
2661 fn resolve_generator_interiors(&self, def_id: DefId) {
2662 let mut generators = self.deferred_generator_interiors.borrow_mut();
2663 for (body_id, interior, kind) in generators.drain(..) {
2664 self.select_obligations_where_possible(false);
2665 generator_interior::resolve_interior(self, def_id, body_id, interior, kind);
2669 // Tries to apply a fallback to `ty` if it is an unsolved variable.
2670 // Non-numerics get replaced with ! or () (depending on whether
2671 // feature(never_type) is enabled, unconstrained ints with i32,
2672 // unconstrained floats with f64.
2673 // Fallback becomes very dubious if we have encountered type-checking errors.
2674 // In that case, fallback to Error.
2675 // The return value indicates whether fallback has occurred.
2676 fn fallback_if_possible(&self, ty: Ty<'tcx>) -> bool {
2677 use rustc::ty::error::UnconstrainedNumeric::Neither;
2678 use rustc::ty::error::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat};
2680 assert!(ty.is_ty_infer());
2681 let fallback = match self.type_is_unconstrained_numeric(ty) {
2682 _ if self.is_tainted_by_errors() => self.tcx().types.err,
2683 UnconstrainedInt => self.tcx.types.i32,
2684 UnconstrainedFloat => self.tcx.types.f64,
2685 Neither if self.type_var_diverges(ty) => self.tcx.mk_diverging_default(),
2686 Neither => return false,
2688 debug!("fallback_if_possible: defaulting `{:?}` to `{:?}`", ty, fallback);
2689 self.demand_eqtype(syntax_pos::DUMMY_SP, ty, fallback);
2693 fn select_all_obligations_or_error(&self) {
2694 debug!("select_all_obligations_or_error");
2695 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
2696 self.report_fulfillment_errors(&errors, self.inh.body_id, false);
2700 /// Select as many obligations as we can at present.
2701 fn select_obligations_where_possible(&self, fallback_has_occurred: bool) {
2702 if let Err(errors) = self.fulfillment_cx.borrow_mut().select_where_possible(self) {
2703 self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
2707 /// For the overloaded place expressions (`*x`, `x[3]`), the trait
2708 /// returns a type of `&T`, but the actual type we assign to the
2709 /// *expression* is `T`. So this function just peels off the return
2710 /// type by one layer to yield `T`.
2711 fn make_overloaded_place_return_type(&self,
2712 method: MethodCallee<'tcx>)
2713 -> ty::TypeAndMut<'tcx>
2715 // extract method return type, which will be &T;
2716 let ret_ty = method.sig.output();
2718 // method returns &T, but the type as visible to user is T, so deref
2719 ret_ty.builtin_deref(true).unwrap()
2725 base_expr: &'tcx hir::Expr,
2729 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2730 // FIXME(#18741) -- this is almost but not quite the same as the
2731 // autoderef that normal method probing does. They could likely be
2734 let mut autoderef = self.autoderef(base_expr.span, base_ty);
2735 let mut result = None;
2736 while result.is_none() && autoderef.next().is_some() {
2737 result = self.try_index_step(expr, base_expr, &autoderef, needs, idx_ty);
2739 autoderef.finalize(self);
2743 /// To type-check `base_expr[index_expr]`, we progressively autoderef
2744 /// (and otherwise adjust) `base_expr`, looking for a type which either
2745 /// supports builtin indexing or overloaded indexing.
2746 /// This loop implements one step in that search; the autoderef loop
2747 /// is implemented by `lookup_indexing`.
2751 base_expr: &hir::Expr,
2752 autoderef: &Autoderef<'a, 'tcx>,
2755 ) -> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)> {
2756 let adjusted_ty = autoderef.unambiguous_final_ty(self);
2757 debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
2764 for &unsize in &[false, true] {
2765 let mut self_ty = adjusted_ty;
2767 // We only unsize arrays here.
2768 if let ty::Array(element_ty, _) = adjusted_ty.sty {
2769 self_ty = self.tcx.mk_slice(element_ty);
2775 // If some lookup succeeds, write callee into table and extract index/element
2776 // type from the method signature.
2777 // If some lookup succeeded, install method in table
2778 let input_ty = self.next_ty_var(TypeVariableOrigin {
2779 kind: TypeVariableOriginKind::AutoDeref,
2780 span: base_expr.span,
2782 let method = self.try_overloaded_place_op(
2783 expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
2785 let result = method.map(|ok| {
2786 debug!("try_index_step: success, using overloaded indexing");
2787 let method = self.register_infer_ok_obligations(ok);
2789 let mut adjustments = autoderef.adjust_steps(self, needs);
2790 if let ty::Ref(region, _, r_mutbl) = method.sig.inputs()[0].sty {
2791 let mutbl = match r_mutbl {
2792 hir::MutImmutable => AutoBorrowMutability::Immutable,
2793 hir::MutMutable => AutoBorrowMutability::Mutable {
2794 // Indexing can be desugared to a method call,
2795 // so maybe we could use two-phase here.
2796 // See the documentation of AllowTwoPhase for why that's
2797 // not the case today.
2798 allow_two_phase_borrow: AllowTwoPhase::No,
2801 adjustments.push(Adjustment {
2802 kind: Adjust::Borrow(AutoBorrow::Ref(region, mutbl)),
2803 target: self.tcx.mk_ref(region, ty::TypeAndMut {
2810 adjustments.push(Adjustment {
2811 kind: Adjust::Pointer(PointerCast::Unsize),
2812 target: method.sig.inputs()[0]
2815 self.apply_adjustments(base_expr, adjustments);
2817 self.write_method_call(expr.hir_id, method);
2818 (input_ty, self.make_overloaded_place_return_type(method).ty)
2820 if result.is_some() {
2828 fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, ast::Ident) {
2829 let (tr, name) = match (op, is_mut) {
2830 (PlaceOp::Deref, false) => (self.tcx.lang_items().deref_trait(), sym::deref),
2831 (PlaceOp::Deref, true) => (self.tcx.lang_items().deref_mut_trait(), sym::deref_mut),
2832 (PlaceOp::Index, false) => (self.tcx.lang_items().index_trait(), sym::index),
2833 (PlaceOp::Index, true) => (self.tcx.lang_items().index_mut_trait(), sym::index_mut),
2835 (tr, ast::Ident::with_empty_ctxt(name))
2838 fn try_overloaded_place_op(&self,
2841 arg_tys: &[Ty<'tcx>],
2844 -> Option<InferOk<'tcx, MethodCallee<'tcx>>>
2846 debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
2852 // Try Mut first, if needed.
2853 let (mut_tr, mut_op) = self.resolve_place_op(op, true);
2854 let method = match (needs, mut_tr) {
2855 (Needs::MutPlace, Some(trait_did)) => {
2856 self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
2861 // Otherwise, fall back to the immutable version.
2862 let (imm_tr, imm_op) = self.resolve_place_op(op, false);
2863 let method = match (method, imm_tr) {
2864 (None, Some(trait_did)) => {
2865 self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))
2867 (method, _) => method,
2873 fn check_method_argument_types(
2877 method: Result<MethodCallee<'tcx>, ()>,
2878 args_no_rcvr: &'tcx [hir::Expr],
2879 tuple_arguments: TupleArgumentsFlag,
2880 expected: Expectation<'tcx>,
2882 let has_error = match method {
2884 method.substs.references_error() || method.sig.references_error()
2889 let err_inputs = self.err_args(args_no_rcvr.len());
2891 let err_inputs = match tuple_arguments {
2892 DontTupleArguments => err_inputs,
2893 TupleArguments => vec![self.tcx.intern_tup(&err_inputs[..])],
2896 self.check_argument_types(sp, expr_sp, &err_inputs[..], &[], args_no_rcvr,
2897 false, tuple_arguments, None);
2898 return self.tcx.types.err;
2901 let method = method.unwrap();
2902 // HACK(eddyb) ignore self in the definition (see above).
2903 let expected_arg_tys = self.expected_inputs_for_expected_output(
2906 method.sig.output(),
2907 &method.sig.inputs()[1..]
2909 self.check_argument_types(sp, expr_sp, &method.sig.inputs()[1..], &expected_arg_tys[..],
2910 args_no_rcvr, method.sig.c_variadic, tuple_arguments,
2911 self.tcx.hir().span_if_local(method.def_id));
2915 fn self_type_matches_expected_vid(
2917 trait_ref: ty::PolyTraitRef<'tcx>,
2918 expected_vid: ty::TyVid,
2920 let self_ty = self.shallow_resolve(trait_ref.self_ty());
2922 "self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?}, expected_vid={:?})",
2923 trait_ref, self_ty, expected_vid
2926 ty::Infer(ty::TyVar(found_vid)) => {
2927 // FIXME: consider using `sub_root_var` here so we
2928 // can see through subtyping.
2929 let found_vid = self.root_var(found_vid);
2930 debug!("self_type_matches_expected_vid - found_vid={:?}", found_vid);
2931 expected_vid == found_vid
2937 fn obligations_for_self_ty<'b>(
2940 ) -> impl Iterator<Item = (ty::PolyTraitRef<'tcx>, traits::PredicateObligation<'tcx>)>
2943 // FIXME: consider using `sub_root_var` here so we
2944 // can see through subtyping.
2945 let ty_var_root = self.root_var(self_ty);
2946 debug!("obligations_for_self_ty: self_ty={:?} ty_var_root={:?} pending_obligations={:?}",
2947 self_ty, ty_var_root,
2948 self.fulfillment_cx.borrow().pending_obligations());
2952 .pending_obligations()
2954 .filter_map(move |obligation| match obligation.predicate {
2955 ty::Predicate::Projection(ref data) =>
2956 Some((data.to_poly_trait_ref(self.tcx), obligation)),
2957 ty::Predicate::Trait(ref data) =>
2958 Some((data.to_poly_trait_ref(), obligation)),
2959 ty::Predicate::Subtype(..) => None,
2960 ty::Predicate::RegionOutlives(..) => None,
2961 ty::Predicate::TypeOutlives(..) => None,
2962 ty::Predicate::WellFormed(..) => None,
2963 ty::Predicate::ObjectSafe(..) => None,
2964 ty::Predicate::ConstEvaluatable(..) => None,
2965 // N.B., this predicate is created by breaking down a
2966 // `ClosureType: FnFoo()` predicate, where
2967 // `ClosureType` represents some `Closure`. It can't
2968 // possibly be referring to the current closure,
2969 // because we haven't produced the `Closure` for
2970 // this closure yet; this is exactly why the other
2971 // code is looking for a self type of a unresolved
2972 // inference variable.
2973 ty::Predicate::ClosureKind(..) => None,
2974 }).filter(move |(tr, _)| self.self_type_matches_expected_vid(*tr, ty_var_root))
2977 fn type_var_is_sized(&self, self_ty: ty::TyVid) -> bool {
2978 self.obligations_for_self_ty(self_ty).any(|(tr, _)| {
2979 Some(tr.def_id()) == self.tcx.lang_items().sized_trait()
2983 /// Generic function that factors out common logic from function calls,
2984 /// method calls and overloaded operators.
2985 fn check_argument_types(
2989 fn_inputs: &[Ty<'tcx>],
2990 expected_arg_tys: &[Ty<'tcx>],
2991 args: &'tcx [hir::Expr],
2993 tuple_arguments: TupleArgumentsFlag,
2994 def_span: Option<Span>,
2998 // Grab the argument types, supplying fresh type variables
2999 // if the wrong number of arguments were supplied
3000 let supplied_arg_count = if tuple_arguments == DontTupleArguments {
3006 // All the input types from the fn signature must outlive the call
3007 // so as to validate implied bounds.
3008 for &fn_input_ty in fn_inputs {
3009 self.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation);
3012 let expected_arg_count = fn_inputs.len();
3014 let param_count_error = |expected_count: usize,
3019 let mut err = tcx.sess.struct_span_err_with_code(sp,
3020 &format!("this function takes {}{} but {} {} supplied",
3021 if c_variadic { "at least " } else { "" },
3022 potentially_plural_count(expected_count, "parameter"),
3023 potentially_plural_count(arg_count, "parameter"),
3024 if arg_count == 1 {"was"} else {"were"}),
3025 DiagnosticId::Error(error_code.to_owned()));
3027 if let Some(def_s) = def_span.map(|sp| tcx.sess.source_map().def_span(sp)) {
3028 err.span_label(def_s, "defined here");
3031 let sugg_span = tcx.sess.source_map().end_point(expr_sp);
3032 // remove closing `)` from the span
3033 let sugg_span = sugg_span.shrink_to_lo();
3034 err.span_suggestion(
3036 "expected the unit value `()`; create it with empty parentheses",
3038 Applicability::MachineApplicable);
3040 err.span_label(sp, format!("expected {}{}",
3041 if c_variadic { "at least " } else { "" },
3042 potentially_plural_count(expected_count, "parameter")));
3047 let mut expected_arg_tys = expected_arg_tys.to_vec();
3049 let formal_tys = if tuple_arguments == TupleArguments {
3050 let tuple_type = self.structurally_resolved_type(sp, fn_inputs[0]);
3051 match tuple_type.sty {
3052 ty::Tuple(arg_types) if arg_types.len() != args.len() => {
3053 param_count_error(arg_types.len(), args.len(), "E0057", false, false);
3054 expected_arg_tys = vec![];
3055 self.err_args(args.len())
3057 ty::Tuple(arg_types) => {
3058 expected_arg_tys = match expected_arg_tys.get(0) {
3059 Some(&ty) => match ty.sty {
3060 ty::Tuple(ref tys) => tys.iter().map(|k| k.expect_ty()).collect(),
3065 arg_types.iter().map(|k| k.expect_ty()).collect()
3068 span_err!(tcx.sess, sp, E0059,
3069 "cannot use call notation; the first type parameter \
3070 for the function trait is neither a tuple nor unit");
3071 expected_arg_tys = vec![];
3072 self.err_args(args.len())
3075 } else if expected_arg_count == supplied_arg_count {
3077 } else if c_variadic {
3078 if supplied_arg_count >= expected_arg_count {
3081 param_count_error(expected_arg_count, supplied_arg_count, "E0060", true, false);
3082 expected_arg_tys = vec![];
3083 self.err_args(supplied_arg_count)
3086 // is the missing argument of type `()`?
3087 let sugg_unit = if expected_arg_tys.len() == 1 && supplied_arg_count == 0 {
3088 self.resolve_vars_if_possible(&expected_arg_tys[0]).is_unit()
3089 } else if fn_inputs.len() == 1 && supplied_arg_count == 0 {
3090 self.resolve_vars_if_possible(&fn_inputs[0]).is_unit()
3094 param_count_error(expected_arg_count, supplied_arg_count, "E0061", false, sugg_unit);
3096 expected_arg_tys = vec![];
3097 self.err_args(supplied_arg_count)
3100 debug!("check_argument_types: formal_tys={:?}",
3101 formal_tys.iter().map(|t| self.ty_to_string(*t)).collect::<Vec<String>>());
3103 // If there is no expectation, expect formal_tys.
3104 let expected_arg_tys = if !expected_arg_tys.is_empty() {
3110 // Check the arguments.
3111 // We do this in a pretty awful way: first we type-check any arguments
3112 // that are not closures, then we type-check the closures. This is so
3113 // that we have more information about the types of arguments when we
3114 // type-check the functions. This isn't really the right way to do this.
3115 for &check_closures in &[false, true] {
3116 debug!("check_closures={}", check_closures);
3118 // More awful hacks: before we check argument types, try to do
3119 // an "opportunistic" vtable resolution of any trait bounds on
3120 // the call. This helps coercions.
3122 self.select_obligations_where_possible(false);
3125 // For C-variadic functions, we don't have a declared type for all of
3126 // the arguments hence we only do our usual type checking with
3127 // the arguments who's types we do know.
3128 let t = if c_variadic {
3130 } else if tuple_arguments == TupleArguments {
3135 for (i, arg) in args.iter().take(t).enumerate() {
3136 // Warn only for the first loop (the "no closures" one).
3137 // Closure arguments themselves can't be diverging, but
3138 // a previous argument can, e.g., `foo(panic!(), || {})`.
3139 if !check_closures {
3140 self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
3143 let is_closure = match arg.node {
3144 ExprKind::Closure(..) => true,
3148 if is_closure != check_closures {
3152 debug!("checking the argument");
3153 let formal_ty = formal_tys[i];
3155 // The special-cased logic below has three functions:
3156 // 1. Provide as good of an expected type as possible.
3157 let expected = Expectation::rvalue_hint(self, expected_arg_tys[i]);
3159 let checked_ty = self.check_expr_with_expectation(&arg, expected);
3161 // 2. Coerce to the most detailed type that could be coerced
3162 // to, which is `expected_ty` if `rvalue_hint` returns an
3163 // `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
3164 let coerce_ty = expected.only_has_type(self).unwrap_or(formal_ty);
3165 // We're processing function arguments so we definitely want to use
3166 // two-phase borrows.
3167 self.demand_coerce(&arg, checked_ty, coerce_ty, AllowTwoPhase::Yes);
3169 // 3. Relate the expected type and the formal one,
3170 // if the expected type was used for the coercion.
3171 self.demand_suptype(arg.span, formal_ty, coerce_ty);
3175 // We also need to make sure we at least write the ty of the other
3176 // arguments which we skipped above.
3178 fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) {
3179 use crate::structured_errors::{VariadicError, StructuredDiagnostic};
3180 VariadicError::new(s, span, t, cast_ty).diagnostic().emit();
3183 for arg in args.iter().skip(expected_arg_count) {
3184 let arg_ty = self.check_expr(&arg);
3186 // There are a few types which get autopromoted when passed via varargs
3187 // in C but we just error out instead and require explicit casts.
3188 let arg_ty = self.structurally_resolved_type(arg.span, arg_ty);
3190 ty::Float(ast::FloatTy::F32) => {
3191 variadic_error(tcx.sess, arg.span, arg_ty, "c_double");
3193 ty::Int(ast::IntTy::I8) | ty::Int(ast::IntTy::I16) | ty::Bool => {
3194 variadic_error(tcx.sess, arg.span, arg_ty, "c_int");
3196 ty::Uint(ast::UintTy::U8) | ty::Uint(ast::UintTy::U16) => {
3197 variadic_error(tcx.sess, arg.span, arg_ty, "c_uint");
3200 let ptr_ty = self.tcx.mk_fn_ptr(arg_ty.fn_sig(self.tcx));
3201 let ptr_ty = self.resolve_vars_if_possible(&ptr_ty);
3202 variadic_error(tcx.sess, arg.span, arg_ty, &ptr_ty.to_string());
3210 fn err_args(&self, len: usize) -> Vec<Ty<'tcx>> {
3211 vec![self.tcx.types.err; len]
3214 // AST fragment checking
3217 expected: Expectation<'tcx>)
3223 ast::LitKind::Str(..) => tcx.mk_static_str(),
3224 ast::LitKind::ByteStr(ref v) => {
3225 tcx.mk_imm_ref(tcx.lifetimes.re_static,
3226 tcx.mk_array(tcx.types.u8, v.len() as u64))
3228 ast::LitKind::Byte(_) => tcx.types.u8,
3229 ast::LitKind::Char(_) => tcx.types.char,
3230 ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
3231 ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
3232 ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
3233 let opt_ty = expected.to_option(self).and_then(|ty| {
3235 ty::Int(_) | ty::Uint(_) => Some(ty),
3236 ty::Char => Some(tcx.types.u8),
3237 ty::RawPtr(..) => Some(tcx.types.usize),
3238 ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
3242 opt_ty.unwrap_or_else(|| self.next_int_var())
3244 ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
3245 ast::LitKind::FloatUnsuffixed(_) => {
3246 let opt_ty = expected.to_option(self).and_then(|ty| {
3248 ty::Float(_) => Some(ty),
3252 opt_ty.unwrap_or_else(|| self.next_float_var())
3254 ast::LitKind::Bool(_) => tcx.types.bool,
3255 ast::LitKind::Err(_) => tcx.types.err,
3259 // Determine the `Self` type, using fresh variables for all variables
3260 // declared on the impl declaration e.g., `impl<A,B> for Vec<(A,B)>`
3261 // would return `($0, $1)` where `$0` and `$1` are freshly instantiated type
3263 pub fn impl_self_ty(&self,
3264 span: Span, // (potential) receiver for this impl
3266 -> TypeAndSubsts<'tcx> {
3267 let ity = self.tcx.type_of(did);
3268 debug!("impl_self_ty: ity={:?}", ity);
3270 let substs = self.fresh_substs_for_item(span, did);
3271 let substd_ty = self.instantiate_type_scheme(span, &substs, &ity);
3273 TypeAndSubsts { substs: substs, ty: substd_ty }
3276 /// Unifies the output type with the expected type early, for more coercions
3277 /// and forward type information on the input expressions.
3278 fn expected_inputs_for_expected_output(&self,
3280 expected_ret: Expectation<'tcx>,
3281 formal_ret: Ty<'tcx>,
3282 formal_args: &[Ty<'tcx>])
3284 let formal_ret = self.resolve_type_vars_with_obligations(formal_ret);
3285 let ret_ty = match expected_ret.only_has_type(self) {
3287 None => return Vec::new()
3289 let expect_args = self.fudge_inference_if_ok(|| {
3290 // Attempt to apply a subtyping relationship between the formal
3291 // return type (likely containing type variables if the function
3292 // is polymorphic) and the expected return type.
3293 // No argument expectations are produced if unification fails.
3294 let origin = self.misc(call_span);
3295 let ures = self.at(&origin, self.param_env).sup(ret_ty, &formal_ret);
3297 // FIXME(#27336) can't use ? here, Try::from_error doesn't default
3298 // to identity so the resulting type is not constrained.
3301 // Process any obligations locally as much as
3302 // we can. We don't care if some things turn
3303 // out unconstrained or ambiguous, as we're
3304 // just trying to get hints here.
3305 self.save_and_restore_in_snapshot_flag(|_| {
3306 let mut fulfill = TraitEngine::new(self.tcx);
3307 for obligation in ok.obligations {
3308 fulfill.register_predicate_obligation(self, obligation);
3310 fulfill.select_where_possible(self)
3311 }).map_err(|_| ())?;
3313 Err(_) => return Err(()),
3316 // Record all the argument types, with the substitutions
3317 // produced from the above subtyping unification.
3318 Ok(formal_args.iter().map(|ty| {
3319 self.resolve_vars_if_possible(ty)
3321 }).unwrap_or_default();
3322 debug!("expected_inputs_for_expected_output(formal={:?} -> {:?}, expected={:?} -> {:?})",
3323 formal_args, formal_ret,
3324 expect_args, expected_ret);
3328 pub fn check_struct_path(&self,
3331 -> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
3332 let path_span = match *qpath {
3333 QPath::Resolved(_, ref path) => path.span,
3334 QPath::TypeRelative(ref qself, _) => qself.span
3336 let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
3337 let variant = match def {
3339 self.set_tainted_by_errors();
3342 Res::Def(DefKind::Variant, _) => {
3344 ty::Adt(adt, substs) => {
3345 Some((adt.variant_of_res(def), adt.did, substs))
3347 _ => bug!("unexpected type: {:?}", ty)
3350 Res::Def(DefKind::Struct, _)
3351 | Res::Def(DefKind::Union, _)
3352 | Res::Def(DefKind::TyAlias, _)
3353 | Res::Def(DefKind::AssocTy, _)
3354 | Res::SelfTy(..) => {
3356 ty::Adt(adt, substs) if !adt.is_enum() => {
3357 Some((adt.non_enum_variant(), adt.did, substs))
3362 _ => bug!("unexpected definition: {:?}", def)
3365 if let Some((variant, did, substs)) = variant {
3366 debug!("check_struct_path: did={:?} substs={:?}", did, substs);
3367 self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
3369 // Check bounds on type arguments used in the path.
3370 let bounds = self.instantiate_bounds(path_span, did, substs);
3371 let cause = traits::ObligationCause::new(path_span, self.body_id,
3372 traits::ItemObligation(did));
3373 self.add_obligations_for_parameters(cause, &bounds);
3377 struct_span_err!(self.tcx.sess, path_span, E0071,
3378 "expected struct, variant or union type, found {}",
3379 ty.sort_string(self.tcx))
3380 .span_label(path_span, "not a struct")
3386 // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
3387 // The newly resolved definition is written into `type_dependent_defs`.
3388 fn finish_resolving_struct_path(&self,
3395 QPath::Resolved(ref maybe_qself, ref path) => {
3396 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
3397 let ty = AstConv::res_to_ty(self, self_ty, path, true);
3400 QPath::TypeRelative(ref qself, ref segment) => {
3401 let ty = self.to_ty(qself);
3403 let res = if let hir::TyKind::Path(QPath::Resolved(_, ref path)) = qself.node {
3408 let result = AstConv::associated_path_to_ty(
3417 let ty = result.map(|(ty, _, _)| ty).unwrap_or(self.tcx().types.err);
3418 let result = result.map(|(_, kind, def_id)| (kind, def_id));
3420 // Write back the new resolution.
3421 self.write_resolution(hir_id, result);
3423 (result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err), ty)
3428 /// Resolves an associated value path into a base type and associated constant, or method
3429 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
3430 pub fn resolve_ty_and_res_ufcs<'b>(&self,
3434 -> (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment])
3436 debug!("resolve_ty_and_res_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
3437 let (ty, qself, item_segment) = match *qpath {
3438 QPath::Resolved(ref opt_qself, ref path) => {
3440 opt_qself.as_ref().map(|qself| self.to_ty(qself)),
3441 &path.segments[..]);
3443 QPath::TypeRelative(ref qself, ref segment) => {
3444 (self.to_ty(qself), qself, segment)
3447 if let Some(&cached_result) = self.tables.borrow().type_dependent_defs().get(hir_id) {
3448 // Return directly on cache hit. This is useful to avoid doubly reporting
3449 // errors with default match binding modes. See #44614.
3450 let def = cached_result.map(|(kind, def_id)| Res::Def(kind, def_id))
3451 .unwrap_or(Res::Err);
3452 return (def, Some(ty), slice::from_ref(&**item_segment));
3454 let item_name = item_segment.ident;
3455 let result = self.resolve_ufcs(span, item_name, ty, hir_id).or_else(|error| {
3456 let result = match error {
3457 method::MethodError::PrivateMatch(kind, def_id, _) => Ok((kind, def_id)),
3458 _ => Err(ErrorReported),
3460 if item_name.name != kw::Invalid {
3461 self.report_method_error(
3465 SelfSource::QPath(qself),
3473 // Write back the new resolution.
3474 self.write_resolution(hir_id, result);
3476 result.map(|(kind, def_id)| Res::Def(kind, def_id)).unwrap_or(Res::Err),
3478 slice::from_ref(&**item_segment),
3482 pub fn check_decl_initializer(
3484 local: &'tcx hir::Local,
3485 init: &'tcx hir::Expr,
3487 // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
3488 // for #42640 (default match binding modes).
3491 let ref_bindings = local.pat.contains_explicit_ref_binding();
3493 let local_ty = self.local_ty(init.span, local.hir_id).revealed_ty;
3494 if let Some(m) = ref_bindings {
3495 // Somewhat subtle: if we have a `ref` binding in the pattern,
3496 // we want to avoid introducing coercions for the RHS. This is
3497 // both because it helps preserve sanity and, in the case of
3498 // ref mut, for soundness (issue #23116). In particular, in
3499 // the latter case, we need to be clear that the type of the
3500 // referent for the reference that results is *equal to* the
3501 // type of the place it is referencing, and not some
3502 // supertype thereof.
3503 let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
3504 self.demand_eqtype(init.span, local_ty, init_ty);
3507 self.check_expr_coercable_to_type(init, local_ty)
3511 pub fn check_decl_local(&self, local: &'tcx hir::Local) {
3512 let t = self.local_ty(local.span, local.hir_id).decl_ty;
3513 self.write_ty(local.hir_id, t);
3515 if let Some(ref init) = local.init {
3516 let init_ty = self.check_decl_initializer(local, &init);
3517 if init_ty.references_error() {
3518 self.write_ty(local.hir_id, init_ty);
3522 self.check_pat_walk(
3525 ty::BindingMode::BindByValue(hir::Mutability::MutImmutable),
3528 let pat_ty = self.node_ty(local.pat.hir_id);
3529 if pat_ty.references_error() {
3530 self.write_ty(local.hir_id, pat_ty);
3534 pub fn check_stmt(&self, stmt: &'tcx hir::Stmt) {
3535 // Don't do all the complex logic below for `DeclItem`.
3537 hir::StmtKind::Item(..) => return,
3538 hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
3541 self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
3543 // Hide the outer diverging and `has_errors` flags.
3544 let old_diverges = self.diverges.get();
3545 let old_has_errors = self.has_errors.get();
3546 self.diverges.set(Diverges::Maybe);
3547 self.has_errors.set(false);
3550 hir::StmtKind::Local(ref l) => {
3551 self.check_decl_local(&l);
3554 hir::StmtKind::Item(_) => {}
3555 hir::StmtKind::Expr(ref expr) => {
3556 // Check with expected type of `()`.
3557 self.check_expr_has_type_or_error(&expr, self.tcx.mk_unit());
3559 hir::StmtKind::Semi(ref expr) => {
3560 self.check_expr(&expr);
3564 // Combine the diverging and `has_error` flags.
3565 self.diverges.set(self.diverges.get() | old_diverges);
3566 self.has_errors.set(self.has_errors.get() | old_has_errors);
3569 pub fn check_block_no_value(&self, blk: &'tcx hir::Block) {
3570 let unit = self.tcx.mk_unit();
3571 let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
3573 // if the block produces a `!` value, that can always be
3574 // (effectively) coerced to unit.
3576 self.demand_suptype(blk.span, unit, ty);
3580 fn check_block_with_expected(
3582 blk: &'tcx hir::Block,
3583 expected: Expectation<'tcx>,
3586 let mut fcx_ps = self.ps.borrow_mut();
3587 let unsafety_state = fcx_ps.recurse(blk);
3588 replace(&mut *fcx_ps, unsafety_state)
3591 // In some cases, blocks have just one exit, but other blocks
3592 // can be targeted by multiple breaks. This can happen both
3593 // with labeled blocks as well as when we desugar
3594 // a `try { ... }` expression.
3598 // 'a: { if true { break 'a Err(()); } Ok(()) }
3600 // Here we would wind up with two coercions, one from
3601 // `Err(())` and the other from the tail expression
3602 // `Ok(())`. If the tail expression is omitted, that's a
3603 // "forced unit" -- unless the block diverges, in which
3604 // case we can ignore the tail expression (e.g., `'a: {
3605 // break 'a 22; }` would not force the type of the block
3607 let tail_expr = blk.expr.as_ref();
3608 let coerce_to_ty = expected.coercion_target_type(self, blk.span);
3609 let coerce = if blk.targeted_by_break {
3610 CoerceMany::new(coerce_to_ty)
3612 let tail_expr: &[P<hir::Expr>] = match tail_expr {
3613 Some(e) => slice::from_ref(e),
3616 CoerceMany::with_coercion_sites(coerce_to_ty, tail_expr)
3619 let prev_diverges = self.diverges.get();
3620 let ctxt = BreakableCtxt {
3621 coerce: Some(coerce),
3625 let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
3626 for s in &blk.stmts {
3630 // check the tail expression **without** holding the
3631 // `enclosing_breakables` lock below.
3632 let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
3634 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
3635 let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
3636 let coerce = ctxt.coerce.as_mut().unwrap();
3637 if let Some(tail_expr_ty) = tail_expr_ty {
3638 let tail_expr = tail_expr.unwrap();
3639 let cause = self.cause(tail_expr.span,
3640 ObligationCauseCode::BlockTailExpression(blk.hir_id));
3646 // Subtle: if there is no explicit tail expression,
3647 // that is typically equivalent to a tail expression
3648 // of `()` -- except if the block diverges. In that
3649 // case, there is no value supplied from the tail
3650 // expression (assuming there are no other breaks,
3651 // this implies that the type of the block will be
3654 // #41425 -- label the implicit `()` as being the
3655 // "found type" here, rather than the "expected type".
3656 if !self.diverges.get().always() {
3657 // #50009 -- Do not point at the entire fn block span, point at the return type
3658 // span, as it is the cause of the requirement, and
3659 // `consider_hint_about_removing_semicolon` will point at the last expression
3660 // if it were a relevant part of the error. This improves usability in editors
3661 // that highlight errors inline.
3662 let mut sp = blk.span;
3663 let mut fn_span = None;
3664 if let Some((decl, ident)) = self.get_parent_fn_decl(blk.hir_id) {
3665 let ret_sp = decl.output.span();
3666 if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
3667 // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the
3668 // output would otherwise be incorrect and even misleading. Make sure
3669 // the span we're aiming at correspond to a `fn` body.
3670 if block_sp == blk.span {
3672 fn_span = Some(ident.span);
3676 coerce.coerce_forced_unit(self, &self.misc(sp), &mut |err| {
3677 if let Some(expected_ty) = expected.only_has_type(self) {
3678 self.consider_hint_about_removing_semicolon(blk, expected_ty, err);
3680 if let Some(fn_span) = fn_span {
3681 err.span_label(fn_span, "this function's body doesn't return");
3689 // If we can break from the block, then the block's exit is always reachable
3690 // (... as long as the entry is reachable) - regardless of the tail of the block.
3691 self.diverges.set(prev_diverges);
3694 let mut ty = ctxt.coerce.unwrap().complete(self);
3696 if self.has_errors.get() || ty.references_error() {
3697 ty = self.tcx.types.err
3700 self.write_ty(blk.hir_id, ty);
3702 *self.ps.borrow_mut() = prev;
3706 fn parent_item_span(&self, id: hir::HirId) -> Option<Span> {
3707 let node = self.tcx.hir().get(self.tcx.hir().get_parent_item(id));
3709 Node::Item(&hir::Item {
3710 node: hir::ItemKind::Fn(_, _, _, body_id), ..
3712 Node::ImplItem(&hir::ImplItem {
3713 node: hir::ImplItemKind::Method(_, body_id), ..
3715 let body = self.tcx.hir().body(body_id);
3716 if let ExprKind::Block(block, _) = &body.value.node {
3717 return Some(block.span);
3725 /// Given a function block's `HirId`, returns its `FnDecl` if it exists, or `None` otherwise.
3726 fn get_parent_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, ast::Ident)> {
3727 let parent = self.tcx.hir().get(self.tcx.hir().get_parent_item(blk_id));
3728 self.get_node_fn_decl(parent).map(|(fn_decl, ident, _)| (fn_decl, ident))
3731 /// Given a function `Node`, return its `FnDecl` if it exists, or `None` otherwise.
3732 fn get_node_fn_decl(&self, node: Node<'tcx>) -> Option<(&'tcx hir::FnDecl, ast::Ident, bool)> {
3734 Node::Item(&hir::Item {
3735 ident, node: hir::ItemKind::Fn(ref decl, ..), ..
3737 // This is less than ideal, it will not suggest a return type span on any
3738 // method called `main`, regardless of whether it is actually the entry point,
3739 // but it will still present it as the reason for the expected type.
3740 Some((decl, ident, ident.name != sym::main))
3742 Node::TraitItem(&hir::TraitItem {
3743 ident, node: hir::TraitItemKind::Method(hir::MethodSig {
3746 }) => Some((decl, ident, true)),
3747 Node::ImplItem(&hir::ImplItem {
3748 ident, node: hir::ImplItemKind::Method(hir::MethodSig {
3751 }) => Some((decl, ident, false)),
3756 /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
3757 /// suggestion can be made, `None` otherwise.
3758 pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
3759 // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
3760 // `while` before reaching it, as block tail returns are not available in them.
3761 self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
3762 let parent = self.tcx.hir().get(blk_id);
3763 self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
3767 /// On implicit return expressions with mismatched types, provides the following suggestions:
3769 /// - Points out the method's return type as the reason for the expected type.
3770 /// - Possible missing semicolon.
3771 /// - Possible missing return type if the return type is the default, and not `fn main()`.
3772 pub fn suggest_mismatched_types_on_tail(
3774 err: &mut DiagnosticBuilder<'tcx>,
3775 expression: &'tcx hir::Expr,
3781 self.suggest_missing_semicolon(err, expression, expected, cause_span);
3782 let mut pointing_at_return_type = false;
3783 if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
3784 pointing_at_return_type = self.suggest_missing_return_type(
3785 err, &fn_decl, expected, found, can_suggest);
3787 self.suggest_ref_or_into(err, expression, expected, found);
3788 pointing_at_return_type
3791 pub fn suggest_ref_or_into(
3793 err: &mut DiagnosticBuilder<'tcx>,
3798 if let Some((sp, msg, suggestion)) = self.check_ref(expr, found, expected) {
3799 err.span_suggestion(
3803 Applicability::MachineApplicable,
3805 } else if !self.check_for_cast(err, expr, found, expected) {
3806 let is_struct_pat_shorthand_field = self.is_hir_id_from_struct_pattern_shorthand_field(
3810 let methods = self.get_conversion_methods(expr.span, expected, found);
3811 if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
3812 let mut suggestions = iter::repeat(&expr_text).zip(methods.iter())
3813 .filter_map(|(receiver, method)| {
3814 let method_call = format!(".{}()", method.ident);
3815 if receiver.ends_with(&method_call) {
3816 None // do not suggest code that is already there (#53348)
3818 let method_call_list = [".to_vec()", ".to_string()"];
3819 let sugg = if receiver.ends_with(".clone()")
3820 && method_call_list.contains(&method_call.as_str()) {
3821 let max_len = receiver.rfind(".").unwrap();
3822 format!("{}{}", &receiver[..max_len], method_call)
3824 format!("{}{}", receiver, method_call)
3826 Some(if is_struct_pat_shorthand_field {
3827 format!("{}: {}", receiver, sugg)
3833 if suggestions.peek().is_some() {
3834 err.span_suggestions(
3836 "try using a conversion method",
3838 Applicability::MaybeIncorrect,
3845 /// A common error is to forget to add a semicolon at the end of a block, e.g.,
3849 /// bar_that_returns_u32()
3853 /// This routine checks if the return expression in a block would make sense on its own as a
3854 /// statement and the return type has been left as default or has been specified as `()`. If so,
3855 /// it suggests adding a semicolon.
3856 fn suggest_missing_semicolon(
3858 err: &mut DiagnosticBuilder<'tcx>,
3859 expression: &'tcx hir::Expr,
3863 if expected.is_unit() {
3864 // `BlockTailExpression` only relevant if the tail expr would be
3865 // useful on its own.
3866 match expression.node {
3867 ExprKind::Call(..) |
3868 ExprKind::MethodCall(..) |
3869 ExprKind::Loop(..) |
3870 ExprKind::Match(..) |
3871 ExprKind::Block(..) => {
3872 let sp = self.tcx.sess.source_map().next_point(cause_span);
3873 err.span_suggestion(
3875 "try adding a semicolon",
3877 Applicability::MachineApplicable);
3884 /// A possible error is to forget to add a return type that is needed:
3888 /// bar_that_returns_u32()
3892 /// This routine checks if the return type is left as default, the method is not part of an
3893 /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
3895 fn suggest_missing_return_type(
3897 err: &mut DiagnosticBuilder<'tcx>,
3898 fn_decl: &hir::FnDecl,
3903 // Only suggest changing the return type for methods that
3904 // haven't set a return type at all (and aren't `fn main()` or an impl).
3905 match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
3906 (&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
3907 err.span_suggestion(
3909 "try adding a return type",
3910 format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
3911 Applicability::MachineApplicable);
3914 (&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
3915 err.span_label(span, "possibly return type missing here?");
3918 (&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
3919 // `fn main()` must return `()`, do not suggest changing return type
3920 err.span_label(span, "expected `()` because of default return type");
3923 // expectation was caused by something else, not the default return
3924 (&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
3925 (&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
3926 // Only point to return type if the expected type is the return type, as if they
3927 // are not, the expectation must have been caused by something else.
3928 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
3930 let ty = AstConv::ast_ty_to_ty(self, ty);
3931 debug!("suggest_missing_return_type: return type {:?}", ty);
3932 debug!("suggest_missing_return_type: expected type {:?}", ty);
3933 if ty.sty == expected.sty {
3934 err.span_label(sp, format!("expected `{}` because of return type",
3943 /// A possible error is to forget to add `.await` when using futures:
3946 /// #![feature(async_await)]
3948 /// async fn make_u32() -> u32 {
3952 /// fn take_u32(x: u32) {}
3954 /// async fn foo() {
3955 /// let x = make_u32();
3960 /// This routine checks if the found type `T` implements `Future<Output=U>` where `U` is the
3961 /// expected type. If this is the case, and we are inside of an async body, it suggests adding
3962 /// `.await` to the tail of the expression.
3963 fn suggest_missing_await(
3965 err: &mut DiagnosticBuilder<'tcx>,
3970 // `.await` is not permitted outside of `async` bodies, so don't bother to suggest if the
3971 // body isn't `async`.
3972 let item_id = self.tcx().hir().get_parent_node(self.body_id);
3973 if let Some(body_id) = self.tcx().hir().maybe_body_owned_by(item_id) {
3974 let body = self.tcx().hir().body(body_id);
3975 if let Some(hir::GeneratorKind::Async) = body.generator_kind {
3977 // Check for `Future` implementations by constructing a predicate to
3978 // prove: `<T as Future>::Output == U`
3979 let future_trait = self.tcx.lang_items().future_trait().unwrap();
3980 let item_def_id = self.tcx.associated_items(future_trait).next().unwrap().def_id;
3981 let predicate = ty::Predicate::Projection(ty::Binder::bind(ty::ProjectionPredicate {
3982 // `<T as Future>::Output`
3983 projection_ty: ty::ProjectionTy {
3985 substs: self.tcx.mk_substs_trait(
3987 self.fresh_substs_for_item(sp, item_def_id)
3994 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
3995 if self.infcx.predicate_may_hold(&obligation) {
3996 if let Ok(code) = self.sess().source_map().span_to_snippet(sp) {
3997 err.span_suggestion(
3999 "consider using `.await` here",
4000 format!("{}.await", code),
4001 Applicability::MaybeIncorrect,
4009 /// A common error is to add an extra semicolon:
4012 /// fn foo() -> usize {
4017 /// This routine checks if the final statement in a block is an
4018 /// expression with an explicit semicolon whose type is compatible
4019 /// with `expected_ty`. If so, it suggests removing the semicolon.
4020 fn consider_hint_about_removing_semicolon(
4022 blk: &'tcx hir::Block,
4023 expected_ty: Ty<'tcx>,
4024 err: &mut DiagnosticBuilder<'_>,
4026 if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) {
4027 err.span_suggestion(
4029 "consider removing this semicolon",
4031 Applicability::MachineApplicable,
4036 fn could_remove_semicolon(&self, blk: &'tcx hir::Block, expected_ty: Ty<'tcx>) -> Option<Span> {
4037 // Be helpful when the user wrote `{... expr;}` and
4038 // taking the `;` off is enough to fix the error.
4039 let last_stmt = blk.stmts.last()?;
4040 let last_expr = match last_stmt.node {
4041 hir::StmtKind::Semi(ref e) => e,
4044 let last_expr_ty = self.node_ty(last_expr.hir_id);
4045 if self.can_sub(self.param_env, last_expr_ty, expected_ty).is_err() {
4048 let original_span = original_sp(last_stmt.span, blk.span);
4049 Some(original_span.with_lo(original_span.hi() - BytePos(1)))
4052 // Instantiates the given path, which must refer to an item with the given
4053 // number of type parameters and type.
4054 pub fn instantiate_value_path(&self,
4055 segments: &[hir::PathSegment],
4056 self_ty: Option<Ty<'tcx>>,
4060 -> (Ty<'tcx>, Res) {
4062 "instantiate_value_path(segments={:?}, self_ty={:?}, res={:?}, hir_id={})",
4071 let path_segs = match res {
4072 Res::Local(_) | Res::SelfCtor(_) => vec![],
4073 Res::Def(kind, def_id) =>
4074 AstConv::def_ids_for_value_path_segments(self, segments, self_ty, kind, def_id),
4075 _ => bug!("instantiate_value_path on {:?}", res),
4078 let mut user_self_ty = None;
4079 let mut is_alias_variant_ctor = false;
4081 Res::Def(DefKind::Ctor(CtorOf::Variant, _), _) => {
4082 if let Some(self_ty) = self_ty {
4083 let adt_def = self_ty.ty_adt_def().unwrap();
4084 user_self_ty = Some(UserSelfTy {
4085 impl_def_id: adt_def.did,
4088 is_alias_variant_ctor = true;
4091 Res::Def(DefKind::Method, def_id)
4092 | Res::Def(DefKind::AssocConst, def_id) => {
4093 let container = tcx.associated_item(def_id).container;
4094 debug!("instantiate_value_path: def_id={:?} container={:?}", def_id, container);
4096 ty::TraitContainer(trait_did) => {
4097 callee::check_legal_trait_for_method_call(tcx, span, trait_did)
4099 ty::ImplContainer(impl_def_id) => {
4100 if segments.len() == 1 {
4101 // `<T>::assoc` will end up here, and so
4102 // can `T::assoc`. It this came from an
4103 // inherent impl, we need to record the
4104 // `T` for posterity (see `UserSelfTy` for
4106 let self_ty = self_ty.expect("UFCS sugared assoc missing Self");
4107 user_self_ty = Some(UserSelfTy {
4118 // Now that we have categorized what space the parameters for each
4119 // segment belong to, let's sort out the parameters that the user
4120 // provided (if any) into their appropriate spaces. We'll also report
4121 // errors if type parameters are provided in an inappropriate place.
4123 let generic_segs: FxHashSet<_> = path_segs.iter().map(|PathSeg(_, index)| index).collect();
4124 let generics_has_err = AstConv::prohibit_generics(
4125 self, segments.iter().enumerate().filter_map(|(index, seg)| {
4126 if !generic_segs.contains(&index) || is_alias_variant_ctor {
4133 if let Res::Local(hid) = res {
4134 let ty = self.local_ty(span, hid).decl_ty;
4135 let ty = self.normalize_associated_types_in(span, &ty);
4136 self.write_ty(hir_id, ty);
4140 if generics_has_err {
4141 // Don't try to infer type parameters when prohibited generic arguments were given.
4142 user_self_ty = None;
4145 // Now we have to compare the types that the user *actually*
4146 // provided against the types that were *expected*. If the user
4147 // did not provide any types, then we want to substitute inference
4148 // variables. If the user provided some types, we may still need
4149 // to add defaults. If the user provided *too many* types, that's
4152 let mut infer_args_for_err = FxHashSet::default();
4153 for &PathSeg(def_id, index) in &path_segs {
4154 let seg = &segments[index];
4155 let generics = tcx.generics_of(def_id);
4156 // Argument-position `impl Trait` is treated as a normal generic
4157 // parameter internally, but we don't allow users to specify the
4158 // parameter's value explicitly, so we have to do some error-
4160 let suppress_errors = AstConv::check_generic_arg_count_for_call(
4165 false, // `is_method_call`
4167 if suppress_errors {
4168 infer_args_for_err.insert(index);
4169 self.set_tainted_by_errors(); // See issue #53251.
4173 let has_self = path_segs.last().map(|PathSeg(def_id, _)| {
4174 tcx.generics_of(*def_id).has_self
4175 }).unwrap_or(false);
4177 let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
4178 let ty = self.impl_self_ty(span, impl_def_id).ty;
4179 let adt_def = ty.ty_adt_def();
4182 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
4183 let variant = adt_def.non_enum_variant();
4184 let ctor_def_id = variant.ctor_def_id.unwrap();
4186 Res::Def(DefKind::Ctor(CtorOf::Struct, variant.ctor_kind), ctor_def_id),
4191 let mut err = tcx.sess.struct_span_err(span,
4192 "the `Self` constructor can only be used with tuple or unit structs");
4193 if let Some(adt_def) = adt_def {
4194 match adt_def.adt_kind() {
4196 err.help("did you mean to use one of the enum's variants?");
4200 err.span_suggestion(
4202 "use curly brackets",
4203 String::from("Self { /* fields */ }"),
4204 Applicability::HasPlaceholders,
4211 return (tcx.types.err, res)
4217 let def_id = res.def_id();
4219 // The things we are substituting into the type should not contain
4220 // escaping late-bound regions, and nor should the base type scheme.
4221 let ty = tcx.type_of(def_id);
4223 let substs = self_ctor_substs.unwrap_or_else(|| AstConv::create_substs_for_generic_args(
4229 // Provide the generic args, and whether types should be inferred.
4231 if let Some(&PathSeg(_, index)) = path_segs.iter().find(|&PathSeg(did, _)| {
4234 // If we've encountered an `impl Trait`-related error, we're just
4235 // going to infer the arguments for better error messages.
4236 if !infer_args_for_err.contains(&index) {
4237 // Check whether the user has provided generic arguments.
4238 if let Some(ref data) = segments[index].args {
4239 return (Some(data), segments[index].infer_args);
4242 return (None, segments[index].infer_args);
4247 // Provide substitutions for parameters for which (valid) arguments have been provided.
4249 match (¶m.kind, arg) {
4250 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
4251 AstConv::ast_region_to_region(self, lt, Some(param)).into()
4253 (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
4254 self.to_ty(ty).into()
4256 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {
4257 self.to_const(&ct.value, self.tcx.type_of(param.def_id)).into()
4259 _ => unreachable!(),
4262 // Provide substitutions for parameters for which arguments are inferred.
4263 |substs, param, infer_args| {
4265 GenericParamDefKind::Lifetime => {
4266 self.re_infer(Some(param), span).unwrap().into()
4268 GenericParamDefKind::Type { has_default, .. } => {
4269 if !infer_args && has_default {
4270 // If we have a default, then we it doesn't matter that we're not
4271 // inferring the type arguments: we provide the default where any
4273 let default = tcx.type_of(param.def_id);
4276 default.subst_spanned(tcx, substs.unwrap(), Some(span))
4279 // If no type arguments were provided, we have to infer them.
4280 // This case also occurs as a result of some malformed input, e.g.
4281 // a lifetime argument being given instead of a type parameter.
4282 // Using inference instead of `Error` gives better error messages.
4283 self.var_for_def(span, param)
4286 GenericParamDefKind::Const => {
4287 // FIXME(const_generics:defaults)
4288 // No const parameters were provided, we have to infer them.
4289 self.var_for_def(span, param)
4294 assert!(!substs.has_escaping_bound_vars());
4295 assert!(!ty.has_escaping_bound_vars());
4297 // First, store the "user substs" for later.
4298 self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
4300 // Add all the obligations that are required, substituting and
4301 // normalized appropriately.
4302 let bounds = self.instantiate_bounds(span, def_id, &substs);
4303 self.add_obligations_for_parameters(
4304 traits::ObligationCause::new(span, self.body_id, traits::ItemObligation(def_id)),
4307 // Substitute the values for the type parameters into the type of
4308 // the referenced item.
4309 let ty_substituted = self.instantiate_type_scheme(span, &substs, &ty);
4311 if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
4312 // In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
4313 // is inherent, there is no `Self` parameter; instead, the impl needs
4314 // type parameters, which we can infer by unifying the provided `Self`
4315 // with the substituted impl type.
4316 // This also occurs for an enum variant on a type alias.
4317 let ty = tcx.type_of(impl_def_id);
4319 let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
4320 match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
4321 Ok(ok) => self.register_infer_ok_obligations(ok),
4323 self.tcx.sess.delay_span_bug(span, &format!(
4324 "instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
4332 self.check_rustc_args_require_const(def_id, hir_id, span);
4334 debug!("instantiate_value_path: type of {:?} is {:?}",
4337 self.write_substs(hir_id, substs);
4339 (ty_substituted, res)
4342 fn check_rustc_args_require_const(&self,
4346 // We're only interested in functions tagged with
4347 // #[rustc_args_required_const], so ignore anything that's not.
4348 if !self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
4352 // If our calling expression is indeed the function itself, we're good!
4353 // If not, generate an error that this can only be called directly.
4354 if let Node::Expr(expr) = self.tcx.hir().get(
4355 self.tcx.hir().get_parent_node(hir_id))
4357 if let ExprKind::Call(ref callee, ..) = expr.node {
4358 if callee.hir_id == hir_id {
4364 self.tcx.sess.span_err(span, "this function can only be invoked \
4365 directly, not through a function pointer");
4368 // Resolves `typ` by a single level if `typ` is a type variable.
4369 // If no resolution is possible, then an error is reported.
4370 // Numeric inference variables may be left unresolved.
4371 pub fn structurally_resolved_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
4372 let ty = self.resolve_type_vars_with_obligations(ty);
4373 if !ty.is_ty_var() {
4376 if !self.is_tainted_by_errors() {
4377 self.need_type_info_err((**self).body_id, sp, ty)
4378 .note("type must be known at this point")
4381 self.demand_suptype(sp, self.tcx.types.err, ty);
4386 fn with_breakable_ctxt<F: FnOnce() -> R, R>(
4389 ctxt: BreakableCtxt<'tcx>,
4391 ) -> (BreakableCtxt<'tcx>, R) {
4394 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4395 index = enclosing_breakables.stack.len();
4396 enclosing_breakables.by_id.insert(id, index);
4397 enclosing_breakables.stack.push(ctxt);
4401 let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
4402 debug_assert!(enclosing_breakables.stack.len() == index + 1);
4403 enclosing_breakables.by_id.remove(&id).expect("missing breakable context");
4404 enclosing_breakables.stack.pop().expect("missing breakable context")
4409 /// Instantiate a QueryResponse in a probe context, without a
4410 /// good ObligationCause.
4411 fn probe_instantiate_query_response(
4414 original_values: &OriginalQueryValues<'tcx>,
4415 query_result: &Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
4416 ) -> InferResult<'tcx, Ty<'tcx>>
4418 self.instantiate_query_response_and_region_obligations(
4419 &traits::ObligationCause::misc(span, self.body_id),
4425 /// Returns `true` if an expression is contained inside the LHS of an assignment expression.
4426 fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
4427 let mut contained_in_place = false;
4429 while let hir::Node::Expr(parent_expr) =
4430 self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
4432 match &parent_expr.node {
4433 hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
4434 if lhs.hir_id == expr_id {
4435 contained_in_place = true;
4441 expr_id = parent_expr.hir_id;
4448 pub fn check_bounds_are_used<'tcx>(tcx: TyCtxt<'tcx>, generics: &ty::Generics, ty: Ty<'tcx>) {
4449 let own_counts = generics.own_counts();
4451 "check_bounds_are_used(n_tys={}, n_cts={}, ty={:?})",
4457 if own_counts.types == 0 {
4461 // Make a vector of booleans initially `false`; set to `true` when used.
4462 let mut types_used = vec![false; own_counts.types];
4464 for leaf_ty in ty.walk() {
4465 if let ty::Param(ty::ParamTy { index, .. }) = leaf_ty.sty {
4466 debug!("found use of ty param num {}", index);
4467 types_used[index as usize - own_counts.lifetimes] = true;
4468 } else if let ty::Error = leaf_ty.sty {
4469 // If there is already another error, do not emit
4470 // an error for not using a type parameter.
4471 assert!(tcx.sess.has_errors());
4476 let types = generics.params.iter().filter(|param| match param.kind {
4477 ty::GenericParamDefKind::Type { .. } => true,
4480 for (&used, param) in types_used.iter().zip(types) {
4482 let id = tcx.hir().as_local_hir_id(param.def_id).unwrap();
4483 let span = tcx.hir().span(id);
4484 struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name)
4485 .span_label(span, "unused type parameter")
4491 fn fatally_break_rust(sess: &Session) {
4492 let handler = sess.diagnostic();
4493 handler.span_bug_no_panic(
4495 "It looks like you're trying to break rust; would you like some ICE?",
4497 handler.note_without_error("the compiler expectedly panicked. this is a feature.");
4498 handler.note_without_error(
4499 "we would appreciate a joke overview: \
4500 https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
4502 handler.note_without_error(&format!("rustc {} running on {}",
4503 option_env!("CFG_VERSION").unwrap_or("unknown_version"),
4504 crate::session::config::host_triple(),
4508 fn potentially_plural_count(count: usize, word: &str) -> String {
4509 format!("{} {}{}", count, word, if count == 1 { "" } else { "s" })